home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / util / BitSet.class (.txt) next >
Encoding:
Java Class File  |  1998-04-23  |  3.9 KB  |  336 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.    private static int subscript(int var0) {
  13.       return var0 >> 6;
  14.    }
  15.  
  16.    private static int bitIndex(int var0) {
  17.       return (var0 << 6) + 63;
  18.    }
  19.  
  20.    public BitSet() {
  21.       this(64);
  22.    }
  23.  
  24.    public BitSet(int var1) {
  25.       if (var1 < 0) {
  26.          throw new NegativeArraySizeException(Integer.toString(var1));
  27.       } else {
  28.          if (var1 + 63 < 0) {
  29.             var1 = 2147483584;
  30.          }
  31.  
  32.          this.bits = new long[subscript(var1 + 63)];
  33.       }
  34.    }
  35.  
  36.    private void ensureCapacity(int var1) {
  37.       int var2 = subscript(var1) + 1;
  38.       if (var2 > this.bits.length) {
  39.          int var3 = Math.max(2 * this.bits.length, var2);
  40.          long[] var4 = new long[var3];
  41.          System.arraycopy(this.bits, 0, var4, 0, this.bits.length);
  42.          this.bits = var4;
  43.       }
  44.  
  45.    }
  46.  
  47.    public void set(int var1) {
  48.       if (var1 < 0) {
  49.          throw new IndexOutOfBoundsException(Integer.toString(var1));
  50.       } else {
  51.          synchronized(this){}
  52.  
  53.          try {
  54.             this.ensureCapacity(var1);
  55.             long[] var10000 = this.bits;
  56.             int var10001 = subscript(var1);
  57.             var10000[var10001] |= 1L << (var1 & 63);
  58.          } catch (Throwable var4) {
  59.             throw var4;
  60.          }
  61.  
  62.       }
  63.    }
  64.  
  65.    public void clear(int var1) {
  66.       if (var1 < 0) {
  67.          throw new IndexOutOfBoundsException(Integer.toString(var1));
  68.       } else {
  69.          synchronized(this){}
  70.  
  71.          try {
  72.             this.ensureCapacity(var1);
  73.             long[] var10000 = this.bits;
  74.             int var10001 = subscript(var1);
  75.             var10000[var10001] &= ~(1L << (var1 & 63));
  76.          } catch (Throwable var4) {
  77.             throw var4;
  78.          }
  79.  
  80.       }
  81.    }
  82.  
  83.    public boolean get(int var1) {
  84.       if (var1 < 0) {
  85.          throw new IndexOutOfBoundsException(Integer.toString(var1));
  86.       } else {
  87.          boolean var2 = false;
  88.          synchronized(this){}
  89.  
  90.          try {
  91.             int var5 = subscript(var1);
  92.             if (var5 < this.bits.length) {
  93.                var2 = (this.bits[var5] & 1L << (var1 & 63)) != 0L;
  94.             }
  95.          } catch (Throwable var7) {
  96.             throw var7;
  97.          }
  98.  
  99.          return var2;
  100.       }
  101.    }
  102.  
  103.    public void and(BitSet var1) {
  104.       if (this != var1) {
  105.          BitSet var2 = this;
  106.          BitSet var3 = var1;
  107.          if (System.identityHashCode(this) > System.identityHashCode(var1)) {
  108.             var2 = var1;
  109.             var3 = this;
  110.          }
  111.  
  112.          synchronized(var2) {
  113.             synchronized(var3){}
  114.  
  115.             try {
  116.                int var8 = this.bits.length;
  117.                int var9 = var1.bits.length;
  118.                int var10 = Math.min(var8, var9);
  119.  
  120.                long[] var16;
  121.                for(int var11 = var10; var11-- > 0; var16[var11] &= var1.bits[var11]) {
  122.                   var16 = this.bits;
  123.                }
  124.  
  125.                while(var10 < var8) {
  126.                   this.bits[var10] = 0L;
  127.                   ++var10;
  128.                }
  129.             } catch (Throwable var14) {
  130.                throw var14;
  131.             }
  132.          }
  133.  
  134.       }
  135.    }
  136.  
  137.    // $FF: renamed from: or (java.util.BitSet) void
  138.    public void method_0(BitSet var1) {
  139.       if (this != var1) {
  140.          BitSet var2 = this;
  141.          BitSet var3 = var1;
  142.          if (System.identityHashCode(this) > System.identityHashCode(var1)) {
  143.             var2 = var1;
  144.             var3 = this;
  145.          }
  146.  
  147.          synchronized(var2) {
  148.             synchronized(var3){}
  149.  
  150.             try {
  151.                int var8 = var1.bits.length;
  152.                if (var8 > 0) {
  153.                   this.ensureCapacity(bitIndex(var8 - 1));
  154.                }
  155.  
  156.                long[] var14;
  157.                for(int var9 = var8; var9-- > 0; var14[var9] |= var1.bits[var9]) {
  158.                   var14 = this.bits;
  159.                }
  160.             } catch (Throwable var12) {
  161.                throw var12;
  162.             }
  163.          }
  164.  
  165.       }
  166.    }
  167.  
  168.    public void xor(BitSet var1) {
  169.       BitSet var2 = this;
  170.       BitSet var3 = var1;
  171.       if (System.identityHashCode(this) > System.identityHashCode(var1)) {
  172.          var2 = var1;
  173.          var3 = this;
  174.       }
  175.  
  176.       synchronized(var2) {
  177.          synchronized(var3){}
  178.  
  179.          try {
  180.             int var8 = var1.bits.length;
  181.             if (var8 > 0) {
  182.                this.ensureCapacity(bitIndex(var8 - 1));
  183.             }
  184.  
  185.             long[] var14;
  186.             for(int var9 = var8; var9-- > 0; var14[var9] ^= var1.bits[var9]) {
  187.                var14 = this.bits;
  188.             }
  189.          } catch (Throwable var12) {
  190.             throw var12;
  191.          }
  192.       }
  193.  
  194.    }
  195.  
  196.    public int hashCode() {
  197.       long var1 = 1234L;
  198.       synchronized(this){}
  199.  
  200.       try {
  201.          int var5 = this.bits.length;
  202.  
  203.          while(true) {
  204.             --var5;
  205.             if (var5 < 0) {
  206.                return (int)(var1 >> 32 ^ var1);
  207.             }
  208.  
  209.             var1 ^= this.bits[var5] * (long)(var5 + 1);
  210.          }
  211.       } catch (Throwable var7) {
  212.          throw var7;
  213.       }
  214.    }
  215.  
  216.    public int size() {
  217.       return this.bits.length << 6;
  218.    }
  219.  
  220.    public boolean equals(Object var1) {
  221.       if (var1 != null && var1 instanceof BitSet) {
  222.          if (this == var1) {
  223.             return true;
  224.          } else {
  225.             BitSet var2 = (BitSet)var1;
  226.             BitSet var3 = this;
  227.             BitSet var4 = var2;
  228.             if (System.identityHashCode(this) > System.identityHashCode(var2)) {
  229.                var3 = var2;
  230.                var4 = this;
  231.             }
  232.  
  233.             boolean var20;
  234.             synchronized(var3) {
  235.                synchronized(var4){}
  236.  
  237.                try {
  238.                   int var10 = this.bits.length;
  239.                   int var11 = var2.bits.length;
  240.                   int var12 = Math.min(var10, var11);
  241.                   int var13 = var12;
  242.  
  243.                   while(var13-- > 0) {
  244.                      if (this.bits[var13] != var2.bits[var13]) {
  245.                         var20 = false;
  246.                         return var20;
  247.                      }
  248.                   }
  249.  
  250.                   if (var10 <= var12) {
  251.                      if (var11 <= var12) {
  252.                         return true;
  253.                      }
  254.  
  255.                      int var14 = var11;
  256.  
  257.                      do {
  258.                         if (var14-- <= var12) {
  259.                            return true;
  260.                         }
  261.                      } while(var2.bits[var14] == 0L);
  262.  
  263.                      var20 = false;
  264.                      return var20;
  265.                   }
  266.  
  267.                   int var21 = var10;
  268.  
  269.                   do {
  270.                      if (var21-- <= var12) {
  271.                         return true;
  272.                      }
  273.                   } while(this.bits[var21] == 0L);
  274.  
  275.                   var20 = false;
  276.                } catch (Throwable var17) {
  277.                   throw var17;
  278.                }
  279.             }
  280.  
  281.             return var20;
  282.          }
  283.       } else {
  284.          return false;
  285.       }
  286.    }
  287.  
  288.    public Object clone() {
  289.       BitSet var1 = null;
  290.       synchronized(this){}
  291.  
  292.       try {
  293.          try {
  294.             var1 = (BitSet)super.clone();
  295.          } catch (CloneNotSupportedException var5) {
  296.             throw new InternalError();
  297.          }
  298.  
  299.          var1.bits = new long[this.bits.length];
  300.          System.arraycopy(this.bits, 0, var1.bits, 0, var1.bits.length);
  301.       } catch (Throwable var6) {
  302.          throw var6;
  303.       }
  304.  
  305.       return var1;
  306.    }
  307.  
  308.    public String toString() {
  309.       StringBuffer var1 = new StringBuffer();
  310.       boolean var2 = false;
  311.       var1.append('{');
  312.       synchronized(this){}
  313.  
  314.       try {
  315.          int var5 = this.size();
  316.  
  317.          for(int var6 = 0; var6 < var5; ++var6) {
  318.             if (this.get(var6)) {
  319.                if (var2) {
  320.                   var1.append(", ");
  321.                } else {
  322.                   var2 = true;
  323.                }
  324.  
  325.                var1.append(var6);
  326.             }
  327.          }
  328.       } catch (Throwable var8) {
  329.          throw var8;
  330.       }
  331.  
  332.       var1.append('}');
  333.       return var1.toString();
  334.    }
  335. }
  336.