2 // modified by Bob Hanson 3/21/2014 6:44:21 AM to reduce this.b$[....] phrases to simply this.h$
\r
3 // BH added ability to use a non-Java key for HTML elements, for example.
\r
4 // BH 8/24/2014 8:48:58 PM all synchronization and inner classes removed
\r
7 Clazz.load([],"java.util.HashtableIterator",[],function(){
\r
8 c$=Clazz.decorateAsClass(function(){
\r
10 this.expectedModCount=0;
\r
12 this.lastEntry=null;
\r
13 this.lastPosition=0;
\r
14 this.canRemove=false;
\r
15 Clazz.instantialize(this,arguments);
\r
16 },java.util,"HashtableIterator",null,java.util.Iterator);
\r
17 Clazz.makeConstructor(c$,
\r
21 this.position=this.h$.lastSlot;
\r
22 this.expectedModCount=this.h$.modCount;
\r
23 },"java.util.AbstractSet");
\r
24 Clazz.overrideMethod(c$,"hasNext",
\r
26 if(this.lastEntry&&this.lastEntry.next){
\r
28 }while(this.position>=this.h$.firstSlot){
\r
29 if(this.h$.elementData[this.position]==null){
\r
36 Clazz.overrideMethod(c$,"next",
\r
38 if(this.expectedModCount==this.h$.modCount){
\r
40 this.lastEntry=this.lastEntry.next;
\r
41 }if(this.lastEntry==null){
\r
42 while(this.position>=this.h$.firstSlot&&(this.lastEntry=this.h$.elementData[this.position])==null){
\r
46 this.lastPosition=this.position;
\r
48 }}if(this.lastEntry){
\r
49 this.canRemove=true;
\r
50 return this.type.get(this.lastEntry);
\r
51 }throw new java.util.NoSuchElementException();
\r
52 }throw new java.util.ConcurrentModificationException();
\r
54 Clazz.overrideMethod(c$,"remove",
\r
56 if(this.expectedModCount==this.h$.modCount){
\r
58 this.canRemove=false;
\r
61 var b=this.h$.elementData[this.lastPosition];
\r
62 if(b===this.lastEntry){
\r
63 this.h$.elementData[this.lastPosition]=b.next;
\r
66 while(b&&b.next!==this.lastEntry){
\r
70 b.next=this.lastEntry.next;
\r
74 this.h$.elementCount--;
\r
75 this.expectedModCount++;
\r
78 throw new IllegalStateException();
\r
79 }}throw new java.util.ConcurrentModificationException();
\r
85 ////////////////////////////
\r
88 Clazz.load([],"java.util.HashtableEnumerator",[],function(){
\r
89 c$=Clazz.decorateAsClass(function(){
\r
93 Clazz.instantialize(this,arguments);
\r
94 },java.util,"HashtableEnumerator",null,java.util.Enumeration);
\r
96 Clazz.makeConstructor(c$,
\r
100 if (this.h$)this.start=this.h$.lastSlot+1;
\r
101 },"~B,java.util.Hashtable");
\r
102 Clazz.overrideMethod(c$,"hasMoreElements",
\r
104 if (!this.h$)return false;
\r
105 if(this.entry)return true;
\r
107 while(--this.start>=this.h$.firstSlot){
\r
108 if(this.h$.elementData[this.start]){
\r
109 this.entry=this.h$.elementData[this.start];
\r
114 Clazz.overrideMethod(c$,"nextElement",
\r
116 if(this.hasMoreElements()){
\r
117 var a=this.key?this.entry.key:this.entry.value;
\r
118 this.entry=this.entry.next;
\r
121 throw new java.util.NoSuchElementException();
\r
125 ////////////////////////////
\r
127 Clazz.load([],"java.util.HashtableEntrySet",[],function(){
\r
128 c$=Clazz.decorateAsClass(function(){
\r
129 Clazz.instantialize(this,arguments);
\r
130 },java.util,"HashtableEntrySet",java.util.AbstractSet);
\r
132 Clazz.makeConstructor(c$,
\r
135 },"java.util.Hashtable");
\r
136 Clazz.overrideMethod(c$,"size",
\r
138 return this.h$.elementCount;
\r
140 Clazz.overrideMethod(c$,"clear",
\r
144 Clazz.overrideMethod(c$,"remove",
\r
146 if(this.contains(object)){
\r
147 this.h$.remove((object).getKey());
\r
151 Clazz.defineMethod(c$,"contains",
\r
153 var entry=this.h$.getEntry((object).getKey());
\r
154 return object.equals(entry);
\r
157 Clazz.overrideMethod(c$,"get",
\r
160 },"java.util.MapEntry");
\r
162 Clazz.defineMethod(c$,"iterator",
\r
164 return new java.util.HashtableIterator(this);
\r
169 ////////////////////////////
\r
171 Clazz.load([],"java.util.HashtableKeySet",[],function(){
\r
172 c$=Clazz.decorateAsClass(function(){
\r
173 Clazz.instantialize(this,arguments);
\r
174 },java.util,"HashtableKeySet",java.util.AbstractSet);
\r
176 Clazz.makeConstructor(c$,
\r
179 },"java.util.Hashtable");
\r
181 Clazz.overrideMethod(c$,"contains",
\r
183 return this.h$.containsKey(object);
\r
185 Clazz.overrideMethod(c$,"size",
\r
187 return this.h$.elementCount;
\r
189 Clazz.overrideMethod(c$,"clear",
\r
193 Clazz.overrideMethod(c$,"remove",
\r
195 if(this.h$.containsKey(key)){
\r
196 this.h$.remove(key);
\r
201 Clazz.overrideMethod(c$,"get",
\r
204 },"java.util.MapEntry");
\r
206 Clazz.overrideMethod(c$,"iterator",
\r
208 return new java.util.HashtableIterator(this);
\r
212 ////////////////////////////
\r
214 Clazz.load([],"java.util.HashtableValueCollection",[],function(){
\r
215 c$=Clazz.decorateAsClass(function(){
\r
216 Clazz.instantialize(this,arguments);
\r
217 },java.util,"HashtableValueCollection",null,java.util.AbstractCollection);
\r
219 Clazz.makeConstructor(c$,
\r
222 },"java.util.Hashtable");
\r
223 Clazz.overrideMethod(c$,"contains",
\r
225 return this.h$.contains(object);
\r
227 Clazz.overrideMethod(c$,"size",
\r
229 return this.h$.elementCount;
\r
231 Clazz.overrideMethod(c$,"clear",
\r
236 Clazz.overrideMethod(c$,"get",
\r
238 return entry.value;
\r
239 },"java.util.MapEntry");
\r
241 Clazz.overrideMethod(c$,"iterator",
\r
243 return new java.util.HashtableIterator(this);
\r
246 ////////////////////////////
\r
249 Clazz.load(["java.util.MapEntry"],"java.util.HashtableEntry",[],function(){
\r
250 c$=Clazz.decorateAsClass(function(){
\r
253 Clazz.instantialize(this,arguments);
\r
254 },java.util,"HashtableEntry",java.util.MapEntry);
\r
255 Clazz.overrideConstructor(c$,
\r
259 this.hashcode=a.hashCode();
\r
261 Clazz.defineMethod(c$,"clone",
\r
263 var a=Clazz.superCall(this,java.util.HashtableEntry,"clone",[]);
\r
264 if(this.next!=null){
\r
265 a.next=this.next.clone();
\r
269 Clazz.overrideMethod(c$,"setValue",
\r
272 throw new NullPointerException();
\r
277 Clazz.defineMethod(c$,"getKeyHash",
\r
279 return this.key.hashCode();
\r
281 Clazz.defineMethod(c$,"equalsKey",
\r
283 return this.hashcode==(!a.hashCode || a.hashCode())&&this.key.equals(a);
\r
285 Clazz.overrideMethod(c$,"toString",
\r
287 return this.key+"="+this.value;
\r
293 ////////////////////////////
\r
296 Clazz.load(["java.util.Dictionary","$.Enumeration","$.HashtableEnumerator","$.Iterator","$.Map","$.MapEntry","$.NoSuchElementException"],"java.util.Hashtable",["java.lang.IllegalArgumentException","$.IllegalStateException","$.NullPointerException","$.StringBuilder","java.util.AbstractCollection","$.AbstractSet","$.Arrays","$.Collections","$.ConcurrentModificationException","java.util.MapEntry.Type","java.util.HashtableEntry"],function(){
\r
297 c$=Clazz.decorateAsClass(function(){
\r
298 this.elementCount=0;
\r
299 this.elementData=null;
\r
305 Clazz.instantialize(this,arguments);
\r
306 },java.util,"Hashtable",java.util.Dictionary,[java.util.Map,Cloneable,java.io.Serializable]);
\r
307 c$.newEntry=Clazz.defineMethod(c$,"newEntry",
\r
308 ($fz=function(key,value,hash){
\r
309 return new java.util.HashtableEntry(key,value);
\r
310 },$fz.isPrivate=true,$fz),"~O,~O,~N");
\r
311 Clazz.overrideConstructor(c$,
\r
313 this.elementCount=0;
\r
314 this.elementData=this.newElementArray(11);
\r
315 this.firstSlot=this.elementData.length;
\r
316 this.loadFactor=0.75;
\r
317 this.computeMaxSize();
\r
319 Clazz.defineMethod(c$,"newElementArray",
\r
320 ($fz=function(size){
\r
321 return new Array(size);
\r
322 },$fz.isPrivate=true,$fz),"~N");
\r
323 Clazz.overrideMethod(c$,"clear",
\r
325 this.elementCount=0;
\r
326 for (var i = this.elementData.length; --i >= 0;)
\r
327 this.elementData[i] = null;
\r
330 Clazz.defineMethod(c$,"clone",
\r
333 var hashtable=Clazz.superCall(this,java.util.Hashtable,"clone",[]);
\r
334 hashtable.elementData=this.elementData.clone();
\r
336 for(var i=this.elementData.length;--i>=0;){
\r
337 if((entry=this.elementData[i])){
\r
338 hashtable.elementData[i]=entry.clone();
\r
342 if(Clazz.instanceOf(e,CloneNotSupportedException)){
\r
349 Clazz.defineMethod(c$,"computeMaxSize",
\r
351 this.threshold=Math.round((this.elementData.length*this.loadFactor));
\r
352 },$fz.isPrivate=true,$fz));
\r
353 Clazz.defineMethod(c$,"contains",
\r
356 throw new NullPointerException();
\r
357 }for(var i=this.elementData.length;--i>=0;){
\r
358 var entry=this.elementData[i];
\r
360 if(value.equals(entry.value)){
\r
367 Clazz.overrideMethod(c$,"containsKey",
\r
369 if(!key.hashCode) {
\r
370 key.hashCode = function(){return 1};
\r
372 key.equals = function(a) {return this == a};
\r
374 return this.getEntry(key)!=null ;
\r
376 Clazz.overrideMethod(c$,"containsValue",
\r
378 return this.contains(value);
\r
380 Clazz.overrideMethod(c$,"elements",
\r
382 if(this.elementCount==0){
\r
383 return java.util.Hashtable.EMPTY_ENUMERATION;
\r
385 return new java.util.HashtableEnumerator(false, this);
\r
387 Clazz.overrideMethod(c$,"entrySet",
\r
389 return new java.util.HashtableEntrySet(this);
\r
391 Clazz.overrideMethod(c$,"equals",
\r
395 }if(Clazz.instanceOf(object,java.util.Map)){
\r
397 if(this.size()!=map.size()){
\r
399 }var entries=this.entrySet();
\r
400 for(var e,$e=map.entrySet().iterator();$e.hasNext()&&((e=$e.next())||true);){
\r
401 if(!entries.contains(e)){
\r
407 Clazz.overrideMethod(c$,"get",
\r
409 if(!key.hashCode) {
\r
410 key.hashCode = function(){return 1};
\r
412 key.equals = function(a) {return this == a};
\r
414 var hash=key.hashCode();
\r
415 var index=(hash&0x7FFFFFFF)%this.elementData.length;
\r
416 var entry=this.elementData[index];
\r
418 if(entry.equalsKey(key,hash)){
\r
419 return entry.value;
\r
424 Clazz.defineMethod(c$,"getEntry",
\r
426 var hash=key.hashCode();
\r
427 var index=(hash&0x7FFFFFFF)%this.elementData.length;
\r
428 var entry=this.elementData[index];
\r
430 if(entry.equalsKey(key,hash)){
\r
436 Clazz.overrideMethod(c$,"hashCode",
\r
439 var it=this.entrySet().iterator();
\r
440 while(it.hasNext()){
\r
441 var entry=it.next();
\r
442 var key=entry.getKey();
\r
443 var value=entry.getValue();
\r
444 var hash=(key!==this?key.hashCode():0)^(value!==this?(value!=null?value.hashCode():0):0);
\r
449 Clazz.overrideMethod(c$,"isEmpty",
\r
451 return this.elementCount==0;
\r
453 Clazz.overrideMethod(c$,"keys",
\r
455 if(this.elementCount==0){
\r
456 return java.util.Hashtable.EMPTY_ENUMERATION;
\r
458 return new java.util.HashtableEnumerator(true, this);
\r
460 Clazz.overrideMethod(c$,"keySet",
\r
462 return new java.util.HashtableKeySet(this);
\r
464 Clazz.overrideMethod(c$,"put",
\r
465 function(key,value){
\r
466 if(key!=null&&value!=null){
\r
467 if(!key.hashCode) {
\r
468 key.hashCode = function(){return 1};
\r
470 key.equals = function(a) {return this == a};
\r
472 var hash=key.hashCode();
\r
473 var index=(hash&0x7FFFFFFF)%this.elementData.length;
\r
474 var entry=this.elementData[index];
\r
475 while(entry!=null&&!entry.equalsKey(key,hash)){
\r
480 if(++this.elementCount>this.threshold){
\r
482 index=(hash&0x7FFFFFFF)%this.elementData.length;
\r
483 }if(index<this.firstSlot){
\r
484 this.firstSlot=index;
\r
485 }if(index>this.lastSlot){
\r
486 this.lastSlot=index;
\r
489 entry=java.util.Hashtable.newEntry(key,value,hash);
\r
490 entry.next=this.elementData[index];
\r
491 this.elementData[index]=entry;
\r
493 }var result=entry.value;
\r
496 }throw new NullPointerException();
\r
498 Clazz.overrideMethod(c$,"putAll",
\r
500 for(var entry,$entry=map.entrySet().iterator();$entry.hasNext()&&((entry=$entry.next())||true);){
\r
501 this.put(entry.getKey(),entry.getValue());
\r
503 },"java.util.Map");
\r
505 Clazz.defineMethod(c$,"rehash",
\r
507 var length=(this.elementData.length<<1)+1;
\r
510 }var newFirst=length;
\r
512 var newData=this.newElementArray(length);
\r
513 for(var i=this.lastSlot+1;--i>=this.firstSlot;){
\r
514 var entry=this.elementData[i];
\r
515 while(entry!=null){
\r
516 var index=(entry.getKeyHash()&0x7FFFFFFF)%length;
\r
517 if(index<newFirst){
\r
519 }if(index>newLast){
\r
521 }var next=entry.next;
\r
522 entry.next=newData[index];
\r
523 newData[index]=entry;
\r
527 this.firstSlot=newFirst;
\r
528 this.lastSlot=newLast;
\r
529 this.elementData=newData;
\r
530 this.computeMaxSize();
\r
532 Clazz.overrideMethod(c$,"remove",
\r
534 var hash=key.hashCode();
\r
535 var index=(hash&0x7FFFFFFF)%this.elementData.length;
\r
537 var entry=this.elementData[index];
\r
538 while(entry!=null&&!entry.equalsKey(key,hash)){
\r
545 this.elementData[index]=entry.next;
\r
547 last.next=entry.next;
\r
548 }this.elementCount--;
\r
549 var result=entry.value;
\r
554 Clazz.overrideMethod(c$,"size",
\r
556 return this.elementCount;
\r
558 Clazz.overrideMethod(c$,"toString",
\r
560 if(this.isEmpty()){
\r
562 }var buffer=new StringBuilder(this.size()*28);
\r
563 buffer.append('{');
\r
564 for(var i=this.lastSlot;i>=this.firstSlot;i--){
\r
565 var entry=this.elementData[i];
\r
566 while(entry!=null){
\r
567 if(entry.key!==this){
\r
568 buffer.append(entry.key);
\r
570 buffer.append("(this Map)");
\r
571 }buffer.append('=');
\r
572 if(entry.value!==this){
\r
573 buffer.append(entry.value);
\r
575 buffer.append("(this Map)");
\r
576 }buffer.append(", ");
\r
580 if(this.elementCount>0){
\r
581 buffer.setLength(buffer.length()-2);
\r
582 }buffer.append('}');
\r
583 return buffer.toString();
\r
585 Clazz.overrideMethod(c$,"values",
\r
587 return new java.util.HashtableValueCollection(this);
\r
589 java.util.Hashtable.EMPTY_ENUMERATION = new java.util.HashtableEnumerator();
\r