era.mi/src/era/mi/logic/Util.java

   1 package era.mi.logic;
   2
   3 import java.util.Arrays;
   4
   5 public final class Util
   6 {
   7
   8         @SuppressWarnings("unchecked")
   9         public static <T> T[] concat(T[]... arrays)
  10         {
  11                 if (arrays.length == 0)
  12                         throw new IllegalArgumentException("Cannot concatenate 0 arrays.");
  13
  14                 int length = 0;
  15                 for (T[] array : arrays)
  16                         length += array.length;
  17
  18                 T[] newArray = Arrays.copyOf(arrays[0], length);
  19                 int appendIndex = arrays[0].length;
  20                 for (int i = 1; i < arrays.length; i++)
  21                 {
  22                         System.arraycopy(arrays[i], 0, newArray, appendIndex, arrays[i].length);
  23                         appendIndex += arrays[i].length;
  24                 }
  25
  26                 return newArray;
  27         }
  28
  29 //      @SuppressWarnings("unchecked")
  30 //      public static <T> T[][] split(T[] array, int... lengths)
  31 //      {
  32 //              //TODO: implement array split again; This version contains an illegal cast
  33 //              int totalLength = 0;
  34 //              for(int length : lengths)
  35 //                      totalLength += length;
  36 //
  37 //              if(totalLength != array.length)
  38 //                      throw new IllegalArgumentException(); //TODO: add proper error message
  39 //
  40 //              Object[][] newArray = new Object[lengths.length][];
  41 //              int splitIndex = 0;
  42 //              for(int i = 0; i < lengths.length; i++)
  43 //              {
  44 //                      System.arraycopy(array, splitIndex, newArray, 0, lengths[i]);
  45 //                      splitIndex += lengths[i];
  46 //              }
  47 //
  48 //              return (T[][]) newArray;
  49 //      }
  50
  51         public static Bit[] and(Bit[] a, Bit[] b)
  52         {
  53                 return binBitOp(a, b, (bA, bB) -> Bit.and(bA, bB));
  54         }
  55
  56         public static Bit[] or(Bit[] a, Bit[] b)
  57         {
  58                 return binBitOp(a, b, (bA, bB) -> Bit.or(bA, bB));
  59         }
  60
  61         public static Bit[] xor(Bit[] a, Bit[] b)
  62         {
  63                 return binBitOp(a, b, (bA, bB) -> Bit.xor(bA, bB));
  64         }
  65
  66         private static Bit[] binBitOp(Bit[] a, Bit[] b, BitOp op)
  67         {
  68                 if (a.length != b.length)
  69                         throw new IllegalArgumentException("Bit Arrays were not of equal length.");
  70                 Bit[] out = new Bit[a.length];
  71                 for (int i = 0; i < a.length; i++)
  72                 {
  73                         out[i] = op.execute(a[i], b[i]);
  74                 }
  75                 return out;
  76         }
  77
  78         public static Bit[] not(Bit[] a)
  79         {
  80                 Bit[] out = new Bit[a.length];
  81                 for (int i = 0; i < a.length; i++)
  82                 {
  83                         out[i] = a[i].not();
  84                 }
  85                 return out;
  86         }
  87
  88         /**
  89          * uses the {@link Bit#combineWith(Bit)} method, does not create a new array, the result is stored in the first array.
  90          *
  91          * @author Christian Femers
  92          */
  93         public static Bit[] combineInto(Bit[] dest, Bit[] addition)
  94         {
  95                 if (dest.length != addition.length)
  96                         throw new IllegalArgumentException("Bit Arrays were not of equal length.");
  97                 for (int i = 0; i < addition.length; i++)
  98                 {
  99                         dest[i] = dest[i].combineWith(addition[i]);
 100                 }
 101                 return dest;
 102         }
 103
 104         interface BitOp
 105         {
 106                 Bit execute(Bit a, Bit b);
 107         }
 108 }