1 // BH minor efficiencies only
\r
3 Clazz.load(["java.util.AbstractMap","$.AbstractSet","$.Iterator","$.Map","$.MapEntry"],"java.util.HashMap",["java.lang.IllegalArgumentException","$.IllegalStateException","java.util.AbstractCollection","$.Arrays","$.ConcurrentModificationException","java.util.MapEntry.Type","java.util.NoSuchElementException"],function(){
\r
4 c$=Clazz.decorateAsClass(function(){
\r
6 this.elementData=null;
\r
10 Clazz.instantialize(this,arguments);
\r
11 },java.util,"HashMap",java.util.AbstractMap,[java.util.Map,Cloneable,java.io.Serializable]);
\r
12 Clazz.defineMethod(c$,"newElementArray",
\r
14 return new Array(s);
\r
16 //Clazz.makeConstructor(c$,
\r
18 //this.construct(16);
\r
20 //Clazz.makeConstructor(c$,
\r
21 //function(capacity){
\r
22 //Clazz.superConstructor(this,java.util.HashMap,[]);
\r
24 //this.elementCount=0;
\r
25 //this.elementData=this.newElementArray(capacity==0?1:capacity);
\r
26 //this.loadFactor=0.75;
\r
27 //this.computeMaxSize();
\r
29 //throw new IllegalArgumentException();
\r
31 Clazz.makeConstructor(c$,
\r
35 Clazz.makeConstructor(c$,
\r
37 Clazz.superConstructor(this,java.util.HashMap,[]);
\r
39 this.elementCount=0;
\r
40 this.elementData=this.newElementArray(capacity==0?1:capacity);
\r
41 this.loadFactor=0.75;
\r
42 this.computeMaxSize();
\r
44 throw new IllegalArgumentException();
\r
46 Clazz.makeConstructor(c$,
\r
47 function(capacity,loadFactor){
\r
48 Clazz.superConstructor(this,java.util.HashMap,[]);
\r
49 if(capacity>=0&&loadFactor>0){
\r
50 this.elementCount=0;
\r
51 this.elementData=this.newElementArray(capacity==0?1:capacity);
\r
52 this.loadFactor=loadFactor;
\r
53 this.computeMaxSize();
\r
55 throw new IllegalArgumentException();
\r
57 Clazz.makeConstructor(c$,
\r
59 this.construct(map.size()<6?11:map.size()*2);
\r
60 Clazz.superCall(this,java.util.HashMap,"putAll",[map]);
\r
65 Clazz.makeConstructor(c$,
\r
66 function(capacity,loadFactor){
\r
67 this.doConstruct(capacity,loadFactor);
\r
70 Clazz.defineMethod(c$, "doConstruct",
\r
71 function(capacity,loadFactor) {
\r
72 capacity || (capacity = 16);
\r
73 loadFactor || (loadFactor = 0.75);
\r
74 if (typeof capacity != "number") {
\r
76 this.loadFactor=loadFactor;
\r
77 this.elementData=this.newElementArray(map.size()<6?11:map.size()*2);
\r
78 this.computeMaxSize();
\r
83 //Clazz.superConstructor(this,java.util.HashMap,[]);
\r
84 if(capacity>=0&&loadFactor>0){
\r
85 this.elementData=this.newElementArray(capacity==0?1:capacity);
\r
86 this.loadFactor=loadFactor;
\r
87 this.computeMaxSize();
\r
89 throw new IllegalArgumentException();
\r
93 //Clazz.makeConstructor(c$,
\r
95 //this.construct(map.size()<6?11:map.size()*2);
\r
96 //Clazz.superCall(this,java.util.HashMap,"putAll",[map]);
\r
97 //},"java.util.Map");
\r
100 Clazz.overrideMethod(c$,"clear",
\r
102 if(this.elementCount>0){
\r
103 this.elementCount=0;
\r
104 java.util.Arrays.fill(this.elementData,null);
\r
107 Clazz.defineMethod(c$,"clone",
\r
109 return this.cloneHM();
\r
112 Clazz.defineMethod(c$,"cloneHM",
\r
115 var map=this.cloneAM();//Clazz.superCall(this,java.util.HashMap,"clone",[]);
\r
116 map.elementData=this.newElementArray(this.elementData.length);
\r
118 for(var i=0;i<this.elementData.length;i++){
\r
119 if((entry=this.elementData[i])!=null){
\r
120 map.elementData[i]=entry.clone();
\r
124 if(Clazz.instanceOf(e,CloneNotSupportedException)){
\r
132 Clazz.defineMethod(c$,"computeMaxSize",
\r
134 this.threshold=Math.round((this.elementData.length*this.loadFactor));
\r
135 },$fz.isPrivate=true,$fz));
\r
136 Clazz.overrideMethod(c$,"containsKey",
\r
138 return this.getEntry(key)!=null;
\r
140 Clazz.defineMethod(c$,"keysEqual",
\r
141 function(k1,entry){
\r
142 var k1Hash=k1==null?0:k1.hashCode();
\r
143 if(k1Hash!=entry.origKeyHash){
\r
145 }if(k1==null&&entry.key==null){
\r
147 }return k1.equals(entry.key);
\r
148 },"~O,java.util.HashMap.Entry");
\r
149 Clazz.overrideMethod(c$,"containsValue",
\r
152 for(var i=this.elementData.length;--i>=0;){
\r
153 var entry=this.elementData[i];
\r
154 while(entry!=null){
\r
155 if(value.equals(entry.value)){
\r
161 for(var i=this.elementData.length;--i>=0;){
\r
162 var entry=this.elementData[i];
\r
163 while(entry!=null){
\r
164 if(entry.value==null){
\r
171 Clazz.overrideMethod(c$,"entrySet",
\r
173 return new java.util.HashMap.HashMapEntrySet(this);
\r
175 Clazz.overrideMethod(c$,"get",
\r
177 var m=this.getEntry(key);
\r
182 Clazz.defineMethod(c$,"getEntry",
\r
184 var index=this.getModuloHash(key);
\r
185 return this.findEntry(key,index);
\r
187 Clazz.defineMethod(c$,"getModuloHash",
\r
191 }return(key.hashCode()&0x7FFFFFFF)%this.elementData.length;
\r
193 Clazz.defineMethod(c$,"findEntry",
\r
194 function(key,index){
\r
196 m=this.elementData[index];
\r
198 while(m!=null&&!this.keysEqual(key,m)){
\r
202 while(m!=null&&m.key!=null){
\r
207 Clazz.overrideMethod(c$,"isEmpty",
\r
209 return this.elementCount==0;
\r
211 Clazz.overrideMethod(c$,"keySet",
\r
213 if(this.$keySet==null){
\r
214 this.$keySet=((Clazz.isClassDefined("java.util.HashMap$1")?0:java.util.HashMap.$HashMap$1$()),Clazz.innerTypeInstance(java.util.HashMap$1,this,null));
\r
215 }return this.$keySet;
\r
217 Clazz.overrideMethod(c$,"put",
\r
218 function(key,value){
\r
219 var index=this.getModuloHash(key);
\r
220 var entry=this.findEntry(key,index);
\r
223 if(++this.elementCount>this.threshold){
\r
225 index=key==null?0:(key.hashCode()&0x7FFFFFFF)%this.elementData.length;
\r
226 }entry=this.createEntry(key,index,value);
\r
228 }var result=entry.value;
\r
232 Clazz.defineMethod(c$,"createEntry",
\r
233 function(key,index,value){
\r
234 var entry=new java.util.HashMap.Entry(key,value);
\r
235 entry.next=this.elementData[index];
\r
236 this.elementData[index]=entry;
\r
239 Clazz.defineMethod(c$,"putAll",
\r
241 if(!map.isEmpty()){
\r
242 var capacity=this.elementCount+map.size();
\r
243 if(capacity>this.threshold){
\r
244 this.rehash(capacity);
\r
246 this.putAllHM(map);
\r
248 }},"java.util.Map");
\r
249 Clazz.defineMethod(c$,"rehash",
\r
250 function(capacity){
\r
251 var length=(capacity==0?1:capacity<<1);
\r
252 var newData=this.newElementArray(length);
\r
253 for(var i=0;i<this.elementData.length;i++){
\r
254 var entry=this.elementData[i];
\r
255 while(entry!=null){
\r
257 var index=key==null?0:(key.hashCode()&0x7FFFFFFF)%length;
\r
258 var next=entry.next;
\r
259 entry.next=newData[index];
\r
260 newData[index]=entry;
\r
264 this.elementData=newData;
\r
265 this.computeMaxSize();
\r
267 Clazz.defineMethod(c$,"rehash",
\r
269 this.rehash(this.elementData.length);
\r
271 Clazz.overrideMethod(c$,"remove",
\r
273 var entry=this.removeEntry(key);
\r
275 return entry.value;
\r
278 Clazz.defineMethod(c$,"removeEntry",
\r
284 index=(key.hashCode()&0x7FFFFFFF)%this.elementData.length;
\r
285 entry=this.elementData[index];
\r
286 while(entry!=null&&!this.keysEqual(key,entry)){
\r
291 entry=this.elementData[0];
\r
292 while(entry!=null&&entry.key!=null){
\r
299 this.elementData[index]=entry.next;
\r
301 last.next=entry.next;
\r
303 this.elementCount--;
\r
306 Clazz.overrideMethod(c$,"size",
\r
308 return this.elementCount;
\r
310 Clazz.overrideMethod(c$,"values",
\r
312 if(this.valuesCollection==null){
\r
313 this.valuesCollection=((Clazz.isClassDefined("java.util.HashMap$2")?0:java.util.HashMap.$HashMap$2$()),Clazz.innerTypeInstance(java.util.HashMap$2,this,null));
\r
314 }return this.valuesCollection;
\r
316 c$.$HashMap$1$=function(){
\r
317 Clazz.pu$h(self.c$);
\r
318 c$=Clazz.declareAnonymous(java.util,"HashMap$1",java.util.AbstractSet);
\r
319 Clazz.overrideMethod(c$,"contains",
\r
321 return this.b$["java.util.HashMap"].containsKey(object);
\r
323 Clazz.overrideMethod(c$,"size",
\r
325 return this.b$["java.util.HashMap"].size();
\r
327 Clazz.overrideMethod(c$,"clear",
\r
329 this.b$["java.util.HashMap"].clear();
\r
331 Clazz.overrideMethod(c$,"remove",
\r
333 if(this.b$["java.util.HashMap"].containsKey(key)){
\r
334 this.b$["java.util.HashMap"].remove(key);
\r
338 Clazz.overrideMethod(c$,"iterator",
\r
340 return new java.util.HashMap.HashMapIterator(((Clazz.isClassDefined("java.util.HashMap$1$1")?0:java.util.HashMap.$HashMap$1$1$()),Clazz.innerTypeInstance(java.util.HashMap$1$1,this,null)),this.b$["java.util.HashMap"]);
\r
344 c$.$HashMap$1$1$=function(){
\r
345 Clazz.pu$h(self.c$);
\r
346 c$=Clazz.declareAnonymous(java.util,"HashMap$1$1",null,java.util.MapEntry.Type);
\r
347 Clazz.overrideMethod(c$,"get",
\r
350 },"java.util.MapEntry");
\r
353 c$.$HashMap$2$=function(){
\r
354 Clazz.pu$h(self.c$);
\r
355 c$=Clazz.declareAnonymous(java.util,"HashMap$2",java.util.AbstractCollection);
\r
356 Clazz.overrideMethod(c$,"contains",
\r
358 return this.b$["java.util.HashMap"].containsValue(object);
\r
360 Clazz.overrideMethod(c$,"size",
\r
362 return this.b$["java.util.HashMap"].size();
\r
364 Clazz.overrideMethod(c$,"clear",
\r
366 this.b$["java.util.HashMap"].clear();
\r
368 Clazz.overrideMethod(c$,"iterator",
\r
370 return new java.util.HashMap.HashMapIterator(((Clazz.isClassDefined("java.util.HashMap$2$1")?0:java.util.HashMap.$HashMap$2$1$()),Clazz.innerTypeInstance(java.util.HashMap$2$1,this,null)),this.b$["java.util.HashMap"]);
\r
374 c$.$HashMap$2$1$=function(){
\r
375 Clazz.pu$h(self.c$);
\r
376 c$=Clazz.declareAnonymous(java.util,"HashMap$2$1",null,java.util.MapEntry.Type);
\r
377 Clazz.overrideMethod(c$,"get",
\r
379 return entry.value;
\r
380 },"java.util.MapEntry");
\r
383 Clazz.pu$h(self.c$);
\r
384 c$=Clazz.decorateAsClass(function(){
\r
385 this.origKeyHash=0;
\r
387 Clazz.instantialize(this,arguments);
\r
388 },java.util.HashMap,"Entry",java.util.MapEntry);
\r
389 Clazz.makeConstructor(c$,
\r
391 Clazz.superConstructor(this,java.util.HashMap.Entry,[a,b]);
\r
392 this.origKeyHash=(a==null?0:a.hashCode());
\r
394 Clazz.defineMethod(c$,"clone",
\r
396 var a=Clazz.superCall(this,java.util.HashMap.Entry,"clone",[]);
\r
397 if(this.next!=null){
\r
398 a.next=this.next.clone();
\r
402 Clazz.pu$h(self.c$);
\r
403 c$=Clazz.decorateAsClass(function(){
\r
405 this.expectedModCount=0;
\r
407 this.canRemove=false;
\r
409 this.lastEntry=null;
\r
410 this.associatedMap=null;
\r
411 Clazz.instantialize(this,arguments);
\r
412 },java.util.HashMap,"HashMapIterator",null,java.util.Iterator);
\r
413 Clazz.makeConstructor(c$,
\r
415 this.associatedMap=b;
\r
417 this.expectedModCount=b.modCount;
\r
418 },"java.util.MapEntry.Type,java.util.HashMap");
\r
419 Clazz.overrideMethod(c$,"hasNext",
\r
421 if(this.entry!=null){
\r
423 }while(this.position<this.associatedMap.elementData.length){
\r
424 if(this.associatedMap.elementData[this.position]==null){
\r
431 Clazz.defineMethod(c$,"checkConcurrentMod",
\r
433 if(this.expectedModCount!=this.associatedMap.modCount){
\r
434 throw new java.util.ConcurrentModificationException();
\r
436 Clazz.overrideMethod(c$,"next",
\r
438 this.checkConcurrentMod();
\r
439 if(!this.hasNext()){
\r
440 throw new java.util.NoSuchElementException();
\r
442 if(this.entry==null){
\r
443 a=this.lastEntry=this.associatedMap.elementData[this.position++];
\r
444 this.entry=this.lastEntry.next;
\r
446 if(this.lastEntry.next!==this.entry){
\r
447 this.lastEntry=this.lastEntry.next;
\r
449 this.entry=this.entry.next;
\r
450 }this.canRemove=true;
\r
451 return this.type.get(a);
\r
453 Clazz.overrideMethod(c$,"remove",
\r
455 this.checkConcurrentMod();
\r
456 if(!this.canRemove){
\r
457 throw new IllegalStateException();
\r
458 }this.canRemove=false;
\r
459 this.associatedMap.modCount++;
\r
460 if(this.lastEntry.next===this.entry){
\r
461 while(this.associatedMap.elementData[--this.position]==null){
\r
463 this.associatedMap.elementData[this.position]=this.associatedMap.elementData[this.position].next;
\r
466 this.lastEntry.next=this.entry;
\r
467 }this.associatedMap.elementCount--;
\r
468 this.expectedModCount++;
\r
471 Clazz.pu$h(self.c$);
\r
472 c$=Clazz.decorateAsClass(function(){
\r
473 this.associatedMap=null;
\r
474 Clazz.instantialize(this,arguments);
\r
475 },java.util.HashMap,"HashMapEntrySet",java.util.AbstractSet);
\r
476 Clazz.makeConstructor(c$,
\r
478 Clazz.superConstructor(this,java.util.HashMap.HashMapEntrySet,[]);
\r
479 this.associatedMap=a;
\r
480 },"java.util.HashMap");
\r
481 Clazz.defineMethod(c$,"hashMap",
\r
483 return this.associatedMap;
\r
485 Clazz.overrideMethod(c$,"size",
\r
487 return this.associatedMap.elementCount;
\r
489 Clazz.overrideMethod(c$,"clear",
\r
491 this.associatedMap.clear();
\r
493 Clazz.overrideMethod(c$,"remove",
\r
495 if(this.contains(a)){
\r
496 this.associatedMap.remove((a).getKey());
\r
500 Clazz.overrideMethod(c$,"contains",
\r
502 if(Clazz.instanceOf(a,java.util.Map.Entry)){
\r
503 var b=this.associatedMap.getEntry((a).getKey());
\r
504 return a.equals(b);
\r
507 Clazz.overrideMethod(c$,"iterator",
\r
509 return new java.util.HashMap.HashMapIterator(((Clazz.isClassDefined("java.util.HashMap$HashMapEntrySet$1")?0:java.util.HashMap.HashMapEntrySet.$HashMap$HashMapEntrySet$1$()),Clazz.innerTypeInstance(java.util.HashMap$HashMapEntrySet$1,this,null)),this.associatedMap);
\r
511 c$.$HashMap$HashMapEntrySet$1$=function(){
\r
512 Clazz.pu$h(self.c$);
\r
513 c$=Clazz.declareAnonymous(java.util,"HashMap$HashMapEntrySet$1",null,java.util.MapEntry.Type);
\r
514 Clazz.overrideMethod(c$,"get",
\r
517 },"java.util.MapEntry");
\r
521 Clazz.defineStatics(c$,
\r
522 "DEFAULT_SIZE",16);
\r