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