1 \feffClazz.load (null, "java.util.BitSet", ["java.lang.IndexOutOfBoundsException", "$.NegativeArraySizeException", "$.StringBuffer", "java.util.Arrays"], function () {
\r
2 c$ = Clazz.decorateAsClass (function () {
\r
4 Clazz.instantialize (this, arguments);
\r
5 }, java.util, "BitSet", null, [Cloneable, java.io.Serializable]);
\r
6 Clazz.makeConstructor (c$,
\r
10 Clazz.makeConstructor (c$,
\r
12 if (nbits < 0) throw new NegativeArraySizeException ();
\r
13 var length = nbits >>> 5;
\r
14 if ((nbits & 4) != 0) ++length;
\r
15 this.bits = Clazz.newArray (length, 0);
\r
17 Clazz.defineMethod (c$, "and",
\r
19 var max = Math.min (this.bits.length, bs.bits.length);
\r
21 for (i = 0; i < max; ++i) this.bits[i] &= bs.bits[i];
\r
23 while (i < this.bits.length) this.bits[i++] = 0;
\r
25 }, "java.util.BitSet");
\r
26 Clazz.defineMethod (c$, "andNot",
\r
28 var i = Math.min (this.bits.length, bs.bits.length);
\r
30 this.bits[i] &= ~bs.bits[i];
\r
32 }, "java.util.BitSet");
\r
33 Clazz.defineMethod (c$, "cardinality",
\r
36 for (var i = this.bits.length - 1; i >= 0; i--) {
\r
37 var a = this.bits[i];
\r
38 if (a == 0) continue ;if (a == -1) {
\r
40 continue ;}a = ((a >> 1) & 0x55555555) + (a & 0x55555555);
\r
41 a = ((a >> 2) & 0x33333333) + (a & 0x33333333);
\r
42 a = ((a >> 4) & 0x0f0f0f0f) + (a & 0x0f0f0f0f);
\r
43 a = ((a >> 8) & 0x00ff00ff) + (a & 0x00ff00ff);
\r
44 card += ((a >> 16) & 0x0000ffff) + (a & 0x0000ffff);
\r
48 Clazz.defineMethod (c$, "clear",
\r
50 java.util.Arrays.fill (this.bits, 0);
\r
52 Clazz.defineMethod (c$, "clear",
\r
54 var offset = pos >> 5;
\r
55 this.ensure (offset);
\r
56 this.bits[offset] &= ~(1 << pos);
\r
58 Clazz.defineMethod (c$, "clear",
\r
59 function (from, to) {
\r
60 if (from < 0 || from > to) throw new IndexOutOfBoundsException ();
\r
61 if (from == to) return ;
\r
62 var lo_offset = from >>> 5;
\r
63 var hi_offset = to >>> 5;
\r
64 this.ensure (hi_offset);
\r
65 if (lo_offset == hi_offset) {
\r
66 this.bits[hi_offset] &= ((1 << from) - 1) | (-1 << to);
\r
68 }this.bits[lo_offset] &= (1 << from) - 1;
\r
69 this.bits[hi_offset] &= -1 << to;
\r
70 for (var i = lo_offset + 1; i < hi_offset; i++) this.bits[i] = 0;
\r
73 Clazz.defineMethod (c$, "clone",
\r
76 var bs = Clazz.superCall (this, java.util.BitSet, "clone", []);
\r
77 bs.bits = this.bits.clone ();
\r
80 if (Clazz.exceptionOf (e, CloneNotSupportedException)) {
\r
87 Clazz.overrideMethod(c$, "equals",
\r
89 if (!(Clazz.instanceOf (obj, java.util.BitSet))) return false;
\r
91 var max = Math.min (this.bits.length, bs.bits.length);
\r
93 for (i = 0; i < max; ++i) if (this.bits[i] != bs.bits[i]) return false;
\r
95 for (var j = i; j < this.bits.length; ++j) if (this.bits[j] != 0) return false;
\r
97 for (var j = i; j < bs.bits.length; ++j) if (bs.bits[j] != 0) return false;
\r
101 Clazz.defineMethod (c$, "flip",
\r
103 var offset = index >> 5;
\r
104 this.ensure (offset);
\r
105 this.bits[offset] ^= 1 << index;
\r
107 Clazz.defineMethod (c$, "flip",
\r
108 function (from, to) {
\r
109 if (from < 0 || from > to) throw new IndexOutOfBoundsException ();
\r
110 if (from == to) return ;
\r
111 var lo_offset = from >>> 5;
\r
112 var hi_offset = to >>> 5;
\r
113 this.ensure (hi_offset);
\r
114 if (lo_offset == hi_offset) {
\r
115 this.bits[hi_offset] ^= (-1 << from) & ((1 << to) - 1);
\r
117 }this.bits[lo_offset] ^= -1 << from;
\r
118 this.bits[hi_offset] ^= (1 << to) - 1;
\r
119 for (var i = lo_offset + 1; i < hi_offset; i++) this.bits[i] ^= -1;
\r
122 Clazz.defineMethod (c$, "get",
\r
124 var offset = pos >> 5;
\r
125 if (offset >= this.bits.length) return false;
\r
126 return (this.bits[offset] & (1 << pos)) != 0;
\r
128 Clazz.defineMethod (c$, "get",
\r
129 function (from, to) {
\r
130 if (from < 0 || from > to) throw new IndexOutOfBoundsException ();
\r
131 var bs = new java.util.BitSet (to - from);
\r
132 var lo_offset = from >>> 5;
\r
133 if (lo_offset >= this.bits.length) return bs;
\r
134 var lo_bit = from & 4;
\r
135 var hi_offset = to >>> 5;
\r
137 var len = Math.min (hi_offset - lo_offset + 1, this.bits.length - lo_offset);
\r
138 System.arraycopy (this.bits, lo_offset, bs.bits, 0, len);
\r
139 if (hi_offset < this.bits.length) bs.bits[hi_offset - lo_offset] &= (1 << to) - 1;
\r
141 }var len = Math.min (hi_offset, this.bits.length - 1);
\r
142 var reverse = ~lo_bit;
\r
144 for (i = 0; lo_offset < len; lo_offset++, i++) bs.bits[i] = ((this.bits[lo_offset] >>> lo_bit) | (this.bits[lo_offset + 1] << reverse));
\r
146 if ((to & 4) > lo_bit) bs.bits[i++] = this.bits[lo_offset] >>> lo_bit;
\r
147 if (hi_offset < this.bits.length) bs.bits[i - 1] &= (1 << (to - from)) - 1;
\r
150 Clazz.overrideMethod(c$, "hashCode",
\r
153 for (var i = this.bits.length; i > 0; ) h ^= i * this.bits[--i];
\r
157 Clazz.defineMethod (c$, "intersects",
\r
159 var i = Math.min (this.bits.length, set.bits.length);
\r
160 while (--i >= 0) if ((this.bits[i] & set.bits[i]) != 0) return true;
\r
163 }, "java.util.BitSet");
\r
164 Clazz.defineMethod (c$, "isEmpty",
\r
166 for (var i = this.bits.length - 1; i >= 0; i--) if (this.bits[i] != 0) return false;
\r
170 Clazz.defineMethod (c$, "length",
\r
173 for (i = this.bits.length - 1; i >= 0 && this.bits[i] == 0; --i) ;
\r
174 if (i < 0) return 0;
\r
175 var b = this.bits[i];
\r
176 var len = (i + 1) * 32;
\r
177 while ((b & 0x80000000) == 0) {
\r
183 Clazz.defineMethod (c$, "nextClearBit",
\r
185 var offset = from >> 5;
\r
186 var mask = 1 << from;
\r
187 while (offset < this.bits.length) {
\r
188 var h = this.bits[offset];
\r
190 if ((h & mask) == 0) return from;
\r
193 } while (mask != 0);
\r
199 Clazz.defineMethod (c$, "nextSetBit",
\r
201 var offset = from >> 5;
\r
202 var mask = 1 << from;
\r
203 while (offset < this.bits.length) {
\r
204 var h = this.bits[offset];
\r
206 if ((h & mask) != 0) return from;
\r
209 } while (mask != 0);
\r
215 Clazz.defineMethod (c$, "or",
\r
217 this.ensure (bs.bits.length - 1);
\r
218 for (var i = bs.bits.length - 1; i >= 0; i--) this.bits[i] |= bs.bits[i];
\r
220 }, "java.util.BitSet");
\r
221 Clazz.defineMethod (c$, "set",
\r
223 var offset = pos >> 5;
\r
224 this.ensure (offset);
\r
225 this.bits[offset] |= 1 << pos;
\r
227 Clazz.defineMethod (c$, "set",
\r
228 function (index, value) {
\r
229 if (value) this.set (index);
\r
230 else this.clear (index);
\r
232 Clazz.defineMethod (c$, "set",
\r
233 function (from, to) {
\r
234 if (from < 0 || from > to) throw new IndexOutOfBoundsException ();
\r
235 if (from == to) return ;
\r
236 var lo_offset = from >>> 5;
\r
237 var hi_offset = to >>> 5;
\r
238 this.ensure (hi_offset);
\r
239 if (lo_offset == hi_offset) {
\r
240 this.bits[hi_offset] |= (-1 << from) & ((1 << to) - 1);
\r
242 }this.bits[lo_offset] |= -1 << from;
\r
243 this.bits[hi_offset] |= (1 << to) - 1;
\r
244 for (var i = lo_offset + 1; i < hi_offset; i++) this.bits[i] = -1;
\r
247 Clazz.defineMethod (c$, "set",
\r
248 function (from, to, value) {
\r
249 if (value) this.set (from, to);
\r
250 else this.clear (from, to);
\r
252 Clazz.defineMethod (c$, "size",
\r
254 return this.bits.length * 32;
\r
256 Clazz.overrideMethod(c$, "toString",
\r
258 var r = new StringBuffer ("{");
\r
260 for (var i = 0; i < this.bits.length; ++i) {
\r
262 var word = this.bits[i];
\r
263 if (word == 0) continue ;for (var j = 0; j < 32; ++j) {
\r
264 if ((word & bit) != 0) {
\r
265 if (!first) r.append (", ");
\r
266 r.append (32 * i + j);
\r
271 return r.append ("}").toString ();
\r
273 Clazz.defineMethod (c$, "xor",
\r
275 this.ensure (bs.bits.length - 1);
\r
276 for (var i = bs.bits.length - 1; i >= 0; i--) this.bits[i] ^= bs.bits[i];
\r
278 }, "java.util.BitSet");
\r
279 Clazz.defineMethod (c$, "ensure",
\r
280 function (lastElt) {
\r
281 if (lastElt >= this.bits.length) {
\r
282 var nd = Clazz.newArray (lastElt + 1, 0);
\r
283 System.arraycopy (this.bits, 0, nd, 0, this.bits.length);
\r
286 Clazz.defineStatics (c$,
\r