home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / demos / VisualAge for Java 2.0 Entry / setup / data1.cab / ide-e / IDE / cache / R0QL24 (.txt) < prev    next >
Encoding:
Java Class File  |  1998-09-16  |  4.8 KB  |  321 lines
  1. package java.util;
  2.  
  3. import java.io.Serializable;
  4.  
  5. public final class BitSet implements Cloneable, Serializable {
  6.    private static final int BITS_PER_UNIT = 6;
  7.    private static final int MASK = 63;
  8.    private long[] bits;
  9.    private static boolean debugging = System.getProperty("debug") != null;
  10.    private static final long serialVersionUID = 7997698588986878753L;
  11.  
  12.    public BitSet() {
  13.       this(64);
  14.    }
  15.  
  16.    public BitSet(int nbits) {
  17.       if (nbits < 0) {
  18.          throw new NegativeArraySizeException(Integer.toString(nbits));
  19.       } else {
  20.          if (nbits + 63 < 0) {
  21.             nbits = 2147483584;
  22.          }
  23.  
  24.          this.bits = new long[subscript(nbits + 63)];
  25.       }
  26.    }
  27.  
  28.    public void and(BitSet set) {
  29.       if (this != set) {
  30.          BitSet first = this;
  31.          BitSet second = set;
  32.          if (System.identityHashCode(this) > System.identityHashCode(set)) {
  33.             first = set;
  34.             second = this;
  35.          }
  36.  
  37.          synchronized(first) {
  38.             synchronized(second){}
  39.  
  40.             try {
  41.                int bitsLength = this.bits.length;
  42.                int setLength = set.bits.length;
  43.                int n = Math.min(bitsLength, setLength);
  44.  
  45.                long[] var14;
  46.                for(int i = n; i-- > 0; var14[i] &= set.bits[i]) {
  47.                   var14 = this.bits;
  48.                }
  49.  
  50.                while(n < bitsLength) {
  51.                   this.bits[n] = 0L;
  52.                   ++n;
  53.                }
  54.             } catch (Throwable var12) {
  55.                throw var12;
  56.             }
  57.          }
  58.  
  59.       }
  60.    }
  61.  
  62.    private static int bitIndex(int subscript) {
  63.       return (subscript << 6) + 63;
  64.    }
  65.  
  66.    public void clear(int bit) {
  67.       if (bit < 0) {
  68.          throw new IndexOutOfBoundsException(Integer.toString(bit));
  69.       } else {
  70.          synchronized(this){}
  71.  
  72.          try {
  73.             this.ensureCapacity(bit);
  74.             long[] var10000 = this.bits;
  75.             int var10001 = subscript(bit);
  76.             var10000[var10001] &= ~(1L << (bit & 63));
  77.          } catch (Throwable var4) {
  78.             throw var4;
  79.          }
  80.  
  81.       }
  82.    }
  83.  
  84.    public Object clone() {
  85.       BitSet result = null;
  86.       synchronized(this){}
  87.  
  88.       try {
  89.          try {
  90.             result = (BitSet)super.clone();
  91.          } catch (CloneNotSupportedException var5) {
  92.             throw new InternalError();
  93.          }
  94.  
  95.          result.bits = new long[this.bits.length];
  96.          System.arraycopy(this.bits, 0, result.bits, 0, result.bits.length);
  97.       } catch (Throwable var6) {
  98.          throw var6;
  99.       }
  100.  
  101.       return result;
  102.    }
  103.  
  104.    private void ensureCapacity(int nth) {
  105.       int required = subscript(nth) + 1;
  106.       if (required > this.bits.length) {
  107.          int request = Math.max(2 * this.bits.length, required);
  108.          long[] newBits = new long[request];
  109.          System.arraycopy(this.bits, 0, newBits, 0, this.bits.length);
  110.          this.bits = newBits;
  111.       }
  112.  
  113.    }
  114.  
  115.    public boolean equals(Object obj) {
  116.       if (obj != null && obj instanceof BitSet) {
  117.          if (this == obj) {
  118.             return true;
  119.          } else {
  120.             BitSet set = (BitSet)obj;
  121.             BitSet first = this;
  122.             BitSet second = set;
  123.             if (System.identityHashCode(this) > System.identityHashCode(set)) {
  124.                first = set;
  125.                second = this;
  126.             }
  127.  
  128.             synchronized(first) {
  129.                synchronized(second) {
  130.                   int bitsLength = this.bits.length;
  131.                   int setLength = set.bits.length;
  132.                   int n = Math.min(bitsLength, setLength);
  133.                   int i = n;
  134.  
  135.                   while(i-- > 0) {
  136.                      if (this.bits[i] != set.bits[i]) {
  137.                         return false;
  138.                      }
  139.                   }
  140.  
  141.                   if (bitsLength > n) {
  142.                      i = bitsLength;
  143.  
  144.                      while(i-- > n) {
  145.                         if (this.bits[i] != 0L) {
  146.                            return false;
  147.                         }
  148.                      }
  149.                   } else if (setLength > n) {
  150.                      i = setLength;
  151.  
  152.                      while(i-- > n) {
  153.                         if (set.bits[i] != 0L) {
  154.                            return false;
  155.                         }
  156.                      }
  157.                   }
  158.                }
  159.             }
  160.  
  161.             return true;
  162.          }
  163.       } else {
  164.          return false;
  165.       }
  166.    }
  167.  
  168.    public boolean get(int bit) {
  169.       if (bit < 0) {
  170.          throw new IndexOutOfBoundsException(Integer.toString(bit));
  171.       } else {
  172.          boolean result = false;
  173.          synchronized(this){}
  174.  
  175.          try {
  176.             int n = subscript(bit);
  177.             if (n < this.bits.length) {
  178.                result = (this.bits[n] & 1L << (bit & 63)) != 0L;
  179.             }
  180.          } catch (Throwable var6) {
  181.             throw var6;
  182.          }
  183.  
  184.          return result;
  185.       }
  186.    }
  187.  
  188.    public int hashCode() {
  189.       long h = 1234L;
  190.       synchronized(this){}
  191.  
  192.       try {
  193.          int i = this.bits.length;
  194.  
  195.          while(true) {
  196.             --i;
  197.             if (i < 0) {
  198.                return (int)(h >> 32 ^ h);
  199.             }
  200.  
  201.             h ^= this.bits[i] * (long)(i + 1);
  202.          }
  203.       } catch (Throwable var6) {
  204.          throw var6;
  205.       }
  206.    }
  207.  
  208.    // $FF: renamed from: or (java.util.BitSet) void
  209.    public void method_0(BitSet set) {
  210.       if (this != set) {
  211.          BitSet first = this;
  212.          BitSet second = set;
  213.          if (System.identityHashCode(this) > System.identityHashCode(set)) {
  214.             first = set;
  215.             second = this;
  216.          }
  217.  
  218.          synchronized(first) {
  219.             synchronized(second){}
  220.  
  221.             try {
  222.                int setLength = set.bits.length;
  223.                if (setLength > 0) {
  224.                   this.ensureCapacity(bitIndex(setLength - 1));
  225.                }
  226.  
  227.                long[] var12;
  228.                for(int i = setLength; i-- > 0; var12[i] |= set.bits[i]) {
  229.                   var12 = this.bits;
  230.                }
  231.             } catch (Throwable var10) {
  232.                throw var10;
  233.             }
  234.          }
  235.  
  236.       }
  237.    }
  238.  
  239.    public void set(int bit) {
  240.       if (bit < 0) {
  241.          throw new IndexOutOfBoundsException(Integer.toString(bit));
  242.       } else {
  243.          synchronized(this){}
  244.  
  245.          try {
  246.             this.ensureCapacity(bit);
  247.             long[] var10000 = this.bits;
  248.             int var10001 = subscript(bit);
  249.             var10000[var10001] |= 1L << (bit & 63);
  250.          } catch (Throwable var4) {
  251.             throw var4;
  252.          }
  253.  
  254.       }
  255.    }
  256.  
  257.    public int size() {
  258.       return this.bits.length << 6;
  259.    }
  260.  
  261.    private static int subscript(int bitIndex) {
  262.       return bitIndex >> 6;
  263.    }
  264.  
  265.    public String toString() {
  266.       StringBuffer buffer = new StringBuffer();
  267.       boolean needSeparator = false;
  268.       buffer.append('{');
  269.       synchronized(this){}
  270.  
  271.       try {
  272.          int limit = this.size();
  273.  
  274.          for(int i = 0; i < limit; ++i) {
  275.             if (this.get(i)) {
  276.                if (needSeparator) {
  277.                   buffer.append(", ");
  278.                } else {
  279.                   needSeparator = true;
  280.                }
  281.  
  282.                buffer.append(i);
  283.             }
  284.          }
  285.       } catch (Throwable var7) {
  286.          throw var7;
  287.       }
  288.  
  289.       buffer.append('}');
  290.       return buffer.toString();
  291.    }
  292.  
  293.    public void xor(BitSet set) {
  294.       BitSet first = this;
  295.       BitSet second = set;
  296.       if (System.identityHashCode(this) > System.identityHashCode(set)) {
  297.          first = set;
  298.          second = this;
  299.       }
  300.  
  301.       synchronized(first) {
  302.          synchronized(second){}
  303.  
  304.          try {
  305.             int setLength = set.bits.length;
  306.             if (setLength > 0) {
  307.                this.ensureCapacity(bitIndex(setLength - 1));
  308.             }
  309.  
  310.             long[] var12;
  311.             for(int i = setLength; i-- > 0; var12[i] ^= set.bits[i]) {
  312.                var12 = this.bits;
  313.             }
  314.          } catch (Throwable var10) {
  315.             throw var10;
  316.          }
  317.       }
  318.  
  319.    }
  320. }
  321.