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