home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / BitSet.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  6.4 KB  |  509 lines
  1. package java.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.ObjectStreamField;
  7. import java.io.Serializable;
  8.  
  9. public class BitSet implements Cloneable, Serializable {
  10.    private static final int ADDRESS_BITS_PER_WORD = 6;
  11.    private static final int BITS_PER_WORD = 64;
  12.    private static final int BIT_INDEX_MASK = 63;
  13.    private static final long WORD_MASK = -1L;
  14.    private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[]{new ObjectStreamField("bits", long[].class)};
  15.    private long[] words;
  16.    private transient int wordsInUse = 0;
  17.    private transient boolean sizeIsSticky = false;
  18.    private static final long serialVersionUID = 7997698588986878753L;
  19.  
  20.    private static int wordIndex(int var0) {
  21.       return var0 >> 6;
  22.    }
  23.  
  24.    private void checkInvariants() {
  25.       assert this.wordsInUse == 0 || this.words[this.wordsInUse - 1] != 0L;
  26.  
  27.       assert this.wordsInUse >= 0 && this.wordsInUse <= this.words.length;
  28.  
  29.       assert this.wordsInUse == this.words.length || this.words[this.wordsInUse] == 0L;
  30.  
  31.    }
  32.  
  33.    private void recalculateWordsInUse() {
  34.       int var1;
  35.       for(var1 = this.wordsInUse - 1; var1 >= 0 && this.words[var1] == 0L; --var1) {
  36.       }
  37.  
  38.       this.wordsInUse = var1 + 1;
  39.    }
  40.  
  41.    public BitSet() {
  42.       this.initWords(64);
  43.       this.sizeIsSticky = false;
  44.    }
  45.  
  46.    public BitSet(int var1) {
  47.       if (var1 < 0) {
  48.          throw new NegativeArraySizeException("nbits < 0: " + var1);
  49.       } else {
  50.          this.initWords(var1);
  51.          this.sizeIsSticky = true;
  52.       }
  53.    }
  54.  
  55.    private void initWords(int var1) {
  56.       this.words = new long[wordIndex(var1 - 1) + 1];
  57.    }
  58.  
  59.    private void ensureCapacity(int var1) {
  60.       if (this.words.length < var1) {
  61.          int var2 = Math.max(2 * this.words.length, var1);
  62.          this.words = Arrays.copyOf(this.words, var2);
  63.          this.sizeIsSticky = false;
  64.       }
  65.  
  66.    }
  67.  
  68.    private void expandTo(int var1) {
  69.       int var2 = var1 + 1;
  70.       if (this.wordsInUse < var2) {
  71.          this.ensureCapacity(var2);
  72.          this.wordsInUse = var2;
  73.       }
  74.  
  75.    }
  76.  
  77.    private static void checkRange(int var0, int var1) {
  78.       if (var0 < 0) {
  79.          throw new IndexOutOfBoundsException("fromIndex < 0: " + var0);
  80.       } else if (var1 < 0) {
  81.          throw new IndexOutOfBoundsException("toIndex < 0: " + var1);
  82.       } else if (var0 > var1) {
  83.          throw new IndexOutOfBoundsException("fromIndex: " + var0 + " > toIndex: " + var1);
  84.       }
  85.    }
  86.  
  87.    public void flip(int var1) {
  88.       if (var1 < 0) {
  89.          throw new IndexOutOfBoundsException("bitIndex < 0: " + var1);
  90.       } else {
  91.          int var2 = wordIndex(var1);
  92.          this.expandTo(var2);
  93.          long[] var10000 = this.words;
  94.          var10000[var2] ^= 1L << var1;
  95.          this.recalculateWordsInUse();
  96.          this.checkInvariants();
  97.       }
  98.    }
  99.  
  100.    public void flip(int var1, int var2) {
  101.       checkRange(var1, var2);
  102.       if (var1 != var2) {
  103.          int var3 = wordIndex(var1);
  104.          int var4 = wordIndex(var2 - 1);
  105.          this.expandTo(var4);
  106.          long var5 = -1L << var1;
  107.          long var7 = -1L >>> -var2;
  108.          if (var3 == var4) {
  109.             long[] var10000 = this.words;
  110.             var10000[var3] ^= var5 & var7;
  111.          } else {
  112.             long[] var10 = this.words;
  113.             var10[var3] ^= var5;
  114.  
  115.             for(int var9 = var3 + 1; var9 < var4; ++var9) {
  116.                var10 = this.words;
  117.                var10[var9] = ~var10[var9];
  118.             }
  119.  
  120.             var10 = this.words;
  121.             var10[var4] ^= var7;
  122.          }
  123.  
  124.          this.recalculateWordsInUse();
  125.          this.checkInvariants();
  126.       }
  127.    }
  128.  
  129.    public void set(int var1) {
  130.       if (var1 < 0) {
  131.          throw new IndexOutOfBoundsException("bitIndex < 0: " + var1);
  132.       } else {
  133.          int var2 = wordIndex(var1);
  134.          this.expandTo(var2);
  135.          long[] var10000 = this.words;
  136.          var10000[var2] |= 1L << var1;
  137.          this.checkInvariants();
  138.       }
  139.    }
  140.  
  141.    public void set(int var1, boolean var2) {
  142.       if (var2) {
  143.          this.set(var1);
  144.       } else {
  145.          this.clear(var1);
  146.       }
  147.  
  148.    }
  149.  
  150.    public void set(int var1, int var2) {
  151.       checkRange(var1, var2);
  152.       if (var1 != var2) {
  153.          int var3 = wordIndex(var1);
  154.          int var4 = wordIndex(var2 - 1);
  155.          this.expandTo(var4);
  156.          long var5 = -1L << var1;
  157.          long var7 = -1L >>> -var2;
  158.          if (var3 == var4) {
  159.             long[] var10000 = this.words;
  160.             var10000[var3] |= var5 & var7;
  161.          } else {
  162.             long[] var10 = this.words;
  163.             var10[var3] |= var5;
  164.  
  165.             for(int var9 = var3 + 1; var9 < var4; ++var9) {
  166.                this.words[var9] = -1L;
  167.             }
  168.  
  169.             var10 = this.words;
  170.             var10[var4] |= var7;
  171.          }
  172.  
  173.          this.checkInvariants();
  174.       }
  175.    }
  176.  
  177.    public void set(int var1, int var2, boolean var3) {
  178.       if (var3) {
  179.          this.set(var1, var2);
  180.       } else {
  181.          this.clear(var1, var2);
  182.       }
  183.  
  184.    }
  185.  
  186.    public void clear(int var1) {
  187.       if (var1 < 0) {
  188.          throw new IndexOutOfBoundsException("bitIndex < 0: " + var1);
  189.       } else {
  190.          int var2 = wordIndex(var1);
  191.          if (var2 < this.wordsInUse) {
  192.             long[] var10000 = this.words;
  193.             var10000[var2] &= ~(1L << var1);
  194.             this.recalculateWordsInUse();
  195.             this.checkInvariants();
  196.          }
  197.       }
  198.    }
  199.  
  200.    public void clear(int var1, int var2) {
  201.       checkRange(var1, var2);
  202.       if (var1 != var2) {
  203.          int var3 = wordIndex(var1);
  204.          if (var3 < this.wordsInUse) {
  205.             int var4 = wordIndex(var2 - 1);
  206.             if (var4 >= this.wordsInUse) {
  207.                var2 = this.length();
  208.                var4 = this.wordsInUse - 1;
  209.             }
  210.  
  211.             long var5 = -1L << var1;
  212.             long var7 = -1L >>> -var2;
  213.             if (var3 == var4) {
  214.                long[] var10000 = this.words;
  215.                var10000[var3] &= ~(var5 & var7);
  216.             } else {
  217.                long[] var10 = this.words;
  218.                var10[var3] &= ~var5;
  219.  
  220.                for(int var9 = var3 + 1; var9 < var4; ++var9) {
  221.                   this.words[var9] = 0L;
  222.                }
  223.  
  224.                var10 = this.words;
  225.                var10[var4] &= ~var7;
  226.             }
  227.  
  228.             this.recalculateWordsInUse();
  229.             this.checkInvariants();
  230.          }
  231.       }
  232.    }
  233.  
  234.    public void clear() {
  235.       while(this.wordsInUse > 0) {
  236.          this.words[--this.wordsInUse] = 0L;
  237.       }
  238.  
  239.    }
  240.  
  241.    public boolean get(int var1) {
  242.       if (var1 < 0) {
  243.          throw new IndexOutOfBoundsException("bitIndex < 0: " + var1);
  244.       } else {
  245.          this.checkInvariants();
  246.          int var2 = wordIndex(var1);
  247.          return var2 < this.wordsInUse && (this.words[var2] & 1L << var1) != 0L;
  248.       }
  249.    }
  250.  
  251.    public BitSet get(int var1, int var2) {
  252.       checkRange(var1, var2);
  253.       this.checkInvariants();
  254.       int var3 = this.length();
  255.       if (var3 > var1 && var1 != var2) {
  256.          if (var2 > var3) {
  257.             var2 = var3;
  258.          }
  259.  
  260.          BitSet var4 = new BitSet(var2 - var1);
  261.          int var5 = wordIndex(var2 - var1 - 1) + 1;
  262.          int var6 = wordIndex(var1);
  263.          boolean var7 = (var1 & 63) == 0;
  264.  
  265.          for(int var8 = 0; var8 < var5 - 1; ++var6) {
  266.             var4.words[var8] = var7 ? this.words[var6] : this.words[var6] >>> var1 | this.words[var6 + 1] << -var1;
  267.             ++var8;
  268.          }
  269.  
  270.          long var10 = -1L >>> -var2;
  271.          var4.words[var5 - 1] = (var2 - 1 & 63) < (var1 & 63) ? this.words[var6] >>> var1 | (this.words[var6 + 1] & var10) << -var1 : (this.words[var6] & var10) >>> var1;
  272.          var4.wordsInUse = var5;
  273.          var4.recalculateWordsInUse();
  274.          var4.checkInvariants();
  275.          return var4;
  276.       } else {
  277.          return new BitSet(0);
  278.       }
  279.    }
  280.  
  281.    public int nextSetBit(int var1) {
  282.       if (var1 < 0) {
  283.          throw new IndexOutOfBoundsException("fromIndex < 0: " + var1);
  284.       } else {
  285.          this.checkInvariants();
  286.          int var2 = wordIndex(var1);
  287.          if (var2 >= this.wordsInUse) {
  288.             return -1;
  289.          } else {
  290.             long var3;
  291.             for(var3 = this.words[var2] & -1L << var1; var3 == 0L; var3 = this.words[var2]) {
  292.                ++var2;
  293.                if (var2 == this.wordsInUse) {
  294.                   return -1;
  295.                }
  296.             }
  297.  
  298.             return var2 * 64 + Long.numberOfTrailingZeros(var3);
  299.          }
  300.       }
  301.    }
  302.  
  303.    public int nextClearBit(int var1) {
  304.       if (var1 < 0) {
  305.          throw new IndexOutOfBoundsException("fromIndex < 0: " + var1);
  306.       } else {
  307.          this.checkInvariants();
  308.          int var2 = wordIndex(var1);
  309.          if (var2 >= this.wordsInUse) {
  310.             return var1;
  311.          } else {
  312.             long var3;
  313.             for(var3 = ~this.words[var2] & -1L << var1; var3 == 0L; var3 = ~this.words[var2]) {
  314.                ++var2;
  315.                if (var2 == this.wordsInUse) {
  316.                   return this.wordsInUse * 64;
  317.                }
  318.             }
  319.  
  320.             return var2 * 64 + Long.numberOfTrailingZeros(var3);
  321.          }
  322.       }
  323.    }
  324.  
  325.    public int length() {
  326.       return this.wordsInUse == 0 ? 0 : 64 * (this.wordsInUse - 1) + (64 - Long.numberOfLeadingZeros(this.words[this.wordsInUse - 1]));
  327.    }
  328.  
  329.    public boolean isEmpty() {
  330.       return this.wordsInUse == 0;
  331.    }
  332.  
  333.    public boolean intersects(BitSet var1) {
  334.       for(int var2 = Math.min(this.wordsInUse, var1.wordsInUse) - 1; var2 >= 0; --var2) {
  335.          if ((this.words[var2] & var1.words[var2]) != 0L) {
  336.             return true;
  337.          }
  338.       }
  339.  
  340.       return false;
  341.    }
  342.  
  343.    public int cardinality() {
  344.       int var1 = 0;
  345.  
  346.       for(int var2 = 0; var2 < this.wordsInUse; ++var2) {
  347.          var1 += Long.bitCount(this.words[var2]);
  348.       }
  349.  
  350.       return var1;
  351.    }
  352.  
  353.    public void and(BitSet var1) {
  354.       if (this != var1) {
  355.          while(this.wordsInUse > var1.wordsInUse) {
  356.             this.words[--this.wordsInUse] = 0L;
  357.          }
  358.  
  359.          for(int var2 = 0; var2 < this.wordsInUse; ++var2) {
  360.             long[] var10000 = this.words;
  361.             var10000[var2] &= var1.words[var2];
  362.          }
  363.  
  364.          this.recalculateWordsInUse();
  365.          this.checkInvariants();
  366.       }
  367.    }
  368.  
  369.    // $FF: renamed from: or (java.util.BitSet) void
  370.    public void method_0(BitSet var1) {
  371.       if (this != var1) {
  372.          int var2 = Math.min(this.wordsInUse, var1.wordsInUse);
  373.          if (this.wordsInUse < var1.wordsInUse) {
  374.             this.ensureCapacity(var1.wordsInUse);
  375.             this.wordsInUse = var1.wordsInUse;
  376.          }
  377.  
  378.          for(int var3 = 0; var3 < var2; ++var3) {
  379.             long[] var10000 = this.words;
  380.             var10000[var3] |= var1.words[var3];
  381.          }
  382.  
  383.          if (var2 < var1.wordsInUse) {
  384.             System.arraycopy(var1.words, var2, this.words, var2, this.wordsInUse - var2);
  385.          }
  386.  
  387.          this.checkInvariants();
  388.       }
  389.    }
  390.  
  391.    public void xor(BitSet var1) {
  392.       int var2 = Math.min(this.wordsInUse, var1.wordsInUse);
  393.       if (this.wordsInUse < var1.wordsInUse) {
  394.          this.ensureCapacity(var1.wordsInUse);
  395.          this.wordsInUse = var1.wordsInUse;
  396.       }
  397.  
  398.       for(int var3 = 0; var3 < var2; ++var3) {
  399.          long[] var10000 = this.words;
  400.          var10000[var3] ^= var1.words[var3];
  401.       }
  402.  
  403.       if (var2 < var1.wordsInUse) {
  404.          System.arraycopy(var1.words, var2, this.words, var2, var1.wordsInUse - var2);
  405.       }
  406.  
  407.       this.recalculateWordsInUse();
  408.       this.checkInvariants();
  409.    }
  410.  
  411.    public void andNot(BitSet var1) {
  412.       for(int var2 = Math.min(this.wordsInUse, var1.wordsInUse) - 1; var2 >= 0; --var2) {
  413.          long[] var10000 = this.words;
  414.          var10000[var2] &= ~var1.words[var2];
  415.       }
  416.  
  417.       this.recalculateWordsInUse();
  418.       this.checkInvariants();
  419.    }
  420.  
  421.    public int hashCode() {
  422.       long var1 = 1234L;
  423.       int var3 = this.wordsInUse;
  424.  
  425.       while(true) {
  426.          --var3;
  427.          if (var3 < 0) {
  428.             return (int)(var1 >> 32 ^ var1);
  429.          }
  430.  
  431.          var1 ^= this.words[var3] * (long)(var3 + 1);
  432.       }
  433.    }
  434.  
  435.    public int size() {
  436.       return this.words.length * 64;
  437.    }
  438.  
  439.    public boolean equals(Object var1) {
  440.       if (!(var1 instanceof BitSet)) {
  441.          return false;
  442.       } else if (this == var1) {
  443.          return true;
  444.       } else {
  445.          BitSet var2 = (BitSet)var1;
  446.          this.checkInvariants();
  447.          var2.checkInvariants();
  448.          if (this.wordsInUse != var2.wordsInUse) {
  449.             return false;
  450.          } else {
  451.             for(int var3 = 0; var3 < this.wordsInUse; ++var3) {
  452.                if (this.words[var3] != var2.words[var3]) {
  453.                   return false;
  454.                }
  455.             }
  456.  
  457.             return true;
  458.          }
  459.       }
  460.    }
  461.  
  462.    public Object clone() {
  463.       if (!this.sizeIsSticky) {
  464.          this.trimToSize();
  465.       }
  466.  
  467.       try {
  468.          BitSet var1 = (BitSet)super.clone();
  469.          var1.words = (long[])this.words.clone();
  470.          var1.checkInvariants();
  471.          return var1;
  472.       } catch (CloneNotSupportedException var2) {
  473.          throw new InternalError();
  474.       }
  475.    }
  476.  
  477.    private void trimToSize() {
  478.       if (this.wordsInUse != this.words.length) {
  479.          this.words = Arrays.copyOf(this.words, this.wordsInUse);
  480.          this.checkInvariants();
  481.       }
  482.  
  483.    }
  484.  
  485.    private void writeObject(ObjectOutputStream var1) throws IOException {
  486.       this.checkInvariants();
  487.       if (!this.sizeIsSticky) {
  488.          this.trimToSize();
  489.       }
  490.  
  491.       ObjectOutputStream.PutField var2 = var1.putFields();
  492.       var2.put("bits", this.words);
  493.       var1.writeFields();
  494.    }
  495.  
  496.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  497.       ObjectInputStream.GetField var2 = var1.readFields();
  498.       this.words = (long[])var2.get("bits", (Object)null);
  499.       this.wordsInUse = this.words.length;
  500.       this.recalculateWordsInUse();
  501.       this.sizeIsSticky = this.words.length > 0 && this.words[this.words.length - 1] == 0L;
  502.       this.checkInvariants();
  503.    }
  504.  
  505.    public String toString() {
  506.       // $FF: Couldn't be decompiled
  507.    }
  508. }
  509.