1 package jdk.internal.nicl.types;
   2 
   3 import java.util.Arrays;
   4 import java.util.function.IntFunction;
   5 import java.util.stream.IntStream;
   6 import java.util.stream.Stream;
   7 
   8 public class BitFields implements Type {
   9     final Scalar storage;
  10     // fields is a list of bits used
  11     final int[] fields;
  12 
  13     public BitFields(Scalar storage, int[] fields) {
  14         this.storage = storage;
  15         this.fields = fields;
  16     }
  17 
  18     public Scalar getStorage() {
  19         return storage;
  20     }
  21 
  22     public Stream<BitField> fields() {
  23         IntFunction<BitField> toBitField = new IntFunction<BitField>() {
  24             int used = 0;
  25 
  26             @Override
  27             public BitField apply(int v) {
  28                 BitField rv = new BitField(storage, used, v);
  29                 used += v;
  30                 return rv;
  31             }
  32         };
  33 
  34         return IntStream.of(fields).mapToObj(toBitField);
  35     }
  36 
  37     @Override
  38     public long getSize() {
  39         return storage.getSize();
  40     }
  41 
  42     @Override
  43     public int hashCode() {
  44         return 31 * Arrays.hashCode(fields) + storage.hashCode();
  45     }
  46 
  47     @Override
  48     public boolean equals(Object o) {
  49         if (!(o instanceof jdk.internal.nicl.types.BitFields)) {
  50             return false;
  51         }
  52         jdk.internal.nicl.types.BitFields other = (jdk.internal.nicl.types.BitFields) o;
  53         if (!other.storage.equals(storage)) {
  54             return false;
  55         }
  56         return Arrays.equals(fields, other.fields);
  57     }
  58 
  59     @Override
  60     public String toString() {
  61         StringBuffer sb = new StringBuffer();
  62         sb.append(storage.toString());
  63         sb.append(':');
  64         for (int count : fields) {
  65             sb.append(count);
  66             sb.append('b');
  67         }
  68         return sb.toString();
  69     }
  70 
  71     public static class BitField implements Type {
  72         final Scalar storage;
  73         final int start_bit;
  74         final int bits;
  75 
  76         BitField(Scalar storage, int start, int bits) {
  77             this.storage = storage;
  78             this.start_bit = start;
  79             this.bits = bits;
  80         }
  81 
  82         @Override
  83         public long getSize() {
  84             return storage.getSize();
  85         }
  86 
  87         @Override
  88         public int hashCode() {
  89             return 31 * start_bit + 13 * bits + storage.hashCode();
  90         }
  91 
  92         @Override
  93         public boolean equals(Object o) {
  94             if (! (o instanceof BitField)) {
  95                 return false;
  96             }
  97             BitField other = (BitField) o;
  98             if (! other.storage.equals(storage)) {
  99                 return false;
 100             }
 101             return start_bit == other.start_bit && bits == other.bits;
 102         }
 103 
 104         @Override
 105         public String toString() {
 106             return storage.toString() + ":" + bits + "b@" + start_bit;
 107         }
 108     }
 109 }