site/swingjs/j2s/java/util/concurrent/ConcurrentHashMap.js

   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(){
   5 this.elementCount=0;
   6 this.elementData=null;
   7 this.loadFactor=0;
   8 this.threshold=0;
   9 this.modCount=0;
  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",
  13 function(s){
  14 return new Array(s);
  15 },"~N");
  16 //Clazz.makeConstructor(c$,
  17 //function(){
  18 //this.construct(16);
  19 //});
  20 //Clazz.makeConstructor(c$,
  21 //function(capacity){
  22 //Clazz.superConstructor(this,java.util.ConcurrentHashMap,[]);
  23 //if(capacity>=0){
  24 //this.elementCount=0;
  25 //this.elementData=this.newElementArray(capacity==0?1:capacity);
  26 //this.loadFactor=0.75;
  27 //this.computeMaxSize();
  28 //}else{
  29 //throw new IllegalArgumentException();
  30 //}},"~N");
  31 Clazz.makeConstructor(c$,
  32 function(){
  33 this.construct(16);
  34 });
  35 Clazz.makeConstructor(c$,
  36 function(capacity){
  37 Clazz.superConstructor(this,java.util.concurrent.ConcurrentHashMap,[]);
  38 if(capacity>=0){
  39 this.elementCount=0;
  40 this.elementData=this.newElementArray(capacity==0?1:capacity);
  41 this.loadFactor=0.75;
  42 this.computeMaxSize();
  43 }else{
  44 throw new IllegalArgumentException();
  45 }},"~N");
  46 Clazz.makeConstructor(c$,
  47 function(capacity,loadFactor){
  48 Clazz.superConstructor(this,java.util.concurrent.ConcurrentHashMap,[]);
  49 if(capacity>=0&&loadFactor>0){
  50 this.elementCount=0;
  51 this.elementData=this.newElementArray(capacity==0?1:capacity);
  52 this.loadFactor=loadFactor;
  53 this.computeMaxSize();
  54 }else{
  55 throw new IllegalArgumentException();
  56 }},"~N,~N");
  57 Clazz.makeConstructor(c$,
  58 function(map){
  59 this.construct(map.size()<6?11:map.size()*2);
  60 Clazz.superCall(this,java.util.concurrent.ConcurrentHashMap,"putAll",[map]);
  61 },"java.util.Map");
  62
  63
  64 /*
  65 Clazz.makeConstructor(c$,
  66 function(capacity,loadFactor){
  67 this.doConstruct(capacity,loadFactor);
  68 },"~N,~N");
  69
  70 Clazz.defineMethod(c$, "doConstruct",
  71 function(capacity,loadFactor) {
  72 capacity || (capacity = 16);
  73 loadFactor || (loadFactor = 0.75);
  74 if (typeof capacity != "number") {
  75  var map = capacity;
  76  this.loadFactor=loadFactor;
  77  this.elementData=this.newElementArray(map.size()<6?11:map.size()*2);
  78  this.computeMaxSize();
  79  this.putAllHM(map);
  80  return;
  81 }
  82
  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();
  88 }else{
  89 throw new IllegalArgumentException();
  90 }
  91 },"~N,~N");
  92
  93 //Clazz.makeConstructor(c$,
  94 //function(map){
  95 //this.construct(map.size()<6?11:map.size()*2);
  96 //Clazz.superCall(this,java.util.ConcurrentHashMap,"putAll",[map]);
  97 //},"java.util.Map");
  98
  99 */
 100 Clazz.overrideMethod(c$,"clear",
 101 function(){
 102 if(this.elementCount>0){
 103 this.elementCount=0;
 104 java.util.Arrays.fill(this.elementData,null);
 105 this.modCount++;
 106 }});
 107 Clazz.defineMethod(c$,"clone",
 108 function(){
 109   return this.cloneHM();
 110 });
 111
 112 Clazz.defineMethod(c$,"cloneHM",
 113 function(){
 114 try{
 115 var map=this.cloneAM();//Clazz.superCall(this,java.util.concurrent.ConcurrentHashMap,"clone",[]);
 116 map.elementData=this.newElementArray(this.elementData.length);
 117 var entry;
 118 for(var i=0;i<this.elementData.length;i++){
 119 if((entry=this.elementData[i])!=null){
 120 map.elementData[i]=entry.clone();
 121 }}
 122 return map;
 123 }catch(e){
 124 if(Clazz.instanceOf(e,CloneNotSupportedException)){
 125 return null;
 126 }else{
 127 throw e;
 128 }
 129 }
 130 });
 131
 132 Clazz.defineMethod(c$,"computeMaxSize",
 133 ($fz=function(){
 134 this.threshold=Math.round((this.elementData.length*this.loadFactor));
 135 },$fz.isPrivate=true,$fz));
 136 Clazz.overrideMethod(c$,"containsKey",
 137 function(key){
 138 return this.getEntry(key)!=null;
 139 },"~O");
 140 Clazz.defineMethod(c$,"keysEqual",
 141 function(k1,entry){
 142 var k1Hash=k1==null?0:k1.hashCode();
 143 if(k1Hash!=entry.origKeyHash){
 144 return false;
 145 }if(k1==null&&entry.key==null){
 146 return true;
 147 }return k1.equals(entry.key);
 148 },"~O,java.util.concurrent.ConcurrentHashMap.Entry");
 149 Clazz.overrideMethod(c$,"containsValue",
 150 function(value){
 151 if(value!=null){
 152 for(var i=this.elementData.length;--i>=0;){
 153 var entry=this.elementData[i];
 154 while(entry!=null){
 155 if(value.equals(entry.value)){
 156 return true;
 157 }entry=entry.next;
 158 }
 159 }
 160 }else{
 161 for(var i=this.elementData.length;--i>=0;){
 162 var entry=this.elementData[i];
 163 while(entry!=null){
 164 if(entry.value==null){
 165 return true;
 166 }entry=entry.next;
 167 }
 168 }
 169 }return false;
 170 },"~O");
 171 Clazz.overrideMethod(c$,"entrySet",
 172 function(){
 173 return new java.util.concurrent.ConcurrentHashMap.ConcurrentHashMapEntrySet(this);
 174 });
 175 Clazz.overrideMethod(c$,"get",
 176 function(key){
 177 var m=this.getEntry(key);
 178 if(m!=null){
 179 return m.value;
 180 }return null;
 181 },"~O");
 182 Clazz.defineMethod(c$,"getEntry",
 183 function(key){
 184 var index=this.getModuloHash(key);
 185 return this.findEntry(key,index);
 186 },"~O");
 187 Clazz.defineMethod(c$,"getModuloHash",
 188 function(key){
 189 if(key==null){
 190 return 0;
 191 }return(key.hashCode()&0x7FFFFFFF)%this.elementData.length;
 192 },"~O");
 193 Clazz.defineMethod(c$,"findEntry",
 194 function(key,index){
 195 var m;
 196 m=this.elementData[index];
 197 if(key!=null){
 198 while(m!=null&&!this.keysEqual(key,m)){
 199 m=m.next;
 200 }
 201 }else{
 202 while(m!=null&&m.key!=null){
 203 m=m.next;
 204 }
 205 }return m;
 206 },"~O,~N");
 207 Clazz.overrideMethod(c$,"isEmpty",
 208 function(){
 209 return this.elementCount==0;
 210 });
 211 Clazz.overrideMethod(c$,"keySet",
 212 function(){
 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;
 216 });
 217 Clazz.overrideMethod(c$,"put",
 218 function(key,value){
 219 var index=this.getModuloHash(key);
 220 var entry=this.findEntry(key,index);
 221 if(entry==null){
 222 this.modCount++;
 223 if(++this.elementCount>this.threshold){
 224 this.rehash();
 225 index=key==null?0:(key.hashCode()&0x7FFFFFFF)%this.elementData.length;
 226 }entry=this.createEntry(key,index,value);
 227 return null;
 228 }var result=entry.value;
 229 entry.value=value;
 230 return result;
 231 },"~O,~O");
 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;
 237 return entry;
 238 },"~O,~N,~O");
 239 Clazz.defineMethod(c$,"putAll",
 240 function(map){
 241 if(!map.isEmpty()){
 242 var capacity=this.elementCount+map.size();
 243 if(capacity>this.threshold){
 244 this.rehash(capacity);
 245 }
 246 this.putAllHM(map);
 247
 248 }},"java.util.Map");
 249 Clazz.defineMethod(c$,"rehash",
 250 function(capacity){
 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];
 255 while(entry!=null){
 256 var key=entry.key;
 257 var index=key==null?0:(key.hashCode()&0x7FFFFFFF)%length;
 258 var next=entry.next;
 259 entry.next=newData[index];
 260 newData[index]=entry;
 261 entry=next;
 262 }
 263 }
 264 this.elementData=newData;
 265 this.computeMaxSize();
 266 },"~N");
 267 Clazz.defineMethod(c$,"rehash",
 268 function(){
 269 this.rehash(this.elementData.length);
 270 });
 271 Clazz.overrideMethod(c$,"remove",
 272 function(key){
 273 var entry=this.removeEntry(key);
 274 if(entry!=null){
 275 return entry.value;
 276 }return null;
 277 },"~O");
 278 Clazz.defineMethod(c$,"removeEntry",
 279 function(key){
 280 var index=0;
 281 var entry;
 282 var last=null;
 283 if(key!=null){
 284 index=(key.hashCode()&0x7FFFFFFF)%this.elementData.length;
 285 entry=this.elementData[index];
 286 while(entry!=null&&!this.keysEqual(key,entry)){
 287 last=entry;
 288 entry=entry.next;
 289 }
 290 }else{
 291 entry=this.elementData[0];
 292 while(entry!=null&&entry.key!=null){
 293 last=entry;
 294 entry=entry.next;
 295 }
 296 }if(entry==null){
 297 return null;
 298 }if(last==null){
 299 this.elementData[index]=entry.next;
 300 }else{
 301 last.next=entry.next;
 302 }this.modCount++;
 303 this.elementCount--;
 304 return entry;
 305 },"~O");
 306 Clazz.overrideMethod(c$,"size",
 307 function(){
 308 return this.elementCount;
 309 });
 310 Clazz.overrideMethod(c$,"values",
 311 function(){
 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;
 315 });
 316 c$.$ConcurrentHashMap$1$=function(){
 317 Clazz.pu$h(self.c$);
 318 c$=Clazz.declareAnonymous(java.util.concurrent,"ConcurrentHashMap$1",java.util.AbstractSet);
 319 Clazz.overrideMethod(c$,"contains",
 320 function(object){
 321 return this.b$["java.util.concurrent.ConcurrentHashMap"].containsKey(object);
 322 },"~O");
 323 Clazz.overrideMethod(c$,"size",
 324 function(){
 325 return this.b$["java.util.concurrent.ConcurrentHashMap"].size();
 326 });
 327 Clazz.overrideMethod(c$,"clear",
 328 function(){
 329 this.b$["java.util.concurrent.ConcurrentHashMap"].clear();
 330 });
 331 Clazz.overrideMethod(c$,"remove",
 332 function(key){
 333 if(this.b$["java.util.concurrent.ConcurrentHashMap"].containsKey(key)){
 334 this.b$["java.util.concurrent.ConcurrentHashMap"].remove(key);
 335 return true;
 336 }return false;
 337 },"~O");
 338 Clazz.overrideMethod(c$,"iterator",
 339 function(){
 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"]);
 341 });
 342 c$=Clazz.p0p();
 343 };
 344 c$.$ConcurrentHashMap$1$1$=function(){
 345 Clazz.pu$h(self.c$);
 346 c$=Clazz.declareAnonymous(java.util.concurrent,"ConcurrentHashMap$1$1",null,java.util.MapEntry.Type);
 347 Clazz.overrideMethod(c$,"get",
 348 function(entry){
 349 return entry.key;
 350 },"java.util.MapEntry");
 351 c$=Clazz.p0p();
 352 };
 353 c$.$ConcurrentHashMap$2$=function(){
 354 Clazz.pu$h(self.c$);
 355 c$=Clazz.declareAnonymous(java.util.concurrent,"ConcurrentHashMap$2",java.util.AbstractCollection);
 356 Clazz.overrideMethod(c$,"contains",
 357 function(object){
 358 return this.b$["java.util.concurrent.ConcurrentHashMap"].containsValue(object);
 359 },"~O");
 360 Clazz.overrideMethod(c$,"size",
 361 function(){
 362 return this.b$["java.util.concurrent.ConcurrentHashMap"].size();
 363 });
 364 Clazz.overrideMethod(c$,"clear",
 365 function(){
 366 this.b$["java.util.concurrent.ConcurrentHashMap"].clear();
 367 });
 368 Clazz.overrideMethod(c$,"iterator",
 369 function(){
 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"]);
 371 });
 372 c$=Clazz.p0p();
 373 };
 374 c$.$ConcurrentHashMap$2$1$=function(){
 375 Clazz.pu$h(self.c$);
 376 c$=Clazz.declareAnonymous(java.util.concurrent,"ConcurrentHashMap$2$1",null,java.util.MapEntry.Type);
 377 Clazz.overrideMethod(c$,"get",
 378 function(entry){
 379 return entry.value;
 380 },"java.util.MapEntry");
 381 c$=Clazz.p0p();
 382 };
 383 Clazz.pu$h(self.c$);
 384 c$=Clazz.decorateAsClass(function(){
 385 this.origKeyHash=0;
 386 this.next=null;
 387 Clazz.instantialize(this,arguments);
 388 },java.util.concurrent.ConcurrentHashMap,"Entry",java.util.MapEntry);
 389 Clazz.makeConstructor(c$,
 390 function(a,b){
 391 Clazz.superConstructor(this,java.util.concurrent.ConcurrentHashMap.Entry,[a,b]);
 392 this.origKeyHash=(a==null?0:a.hashCode());
 393 },"~O,~O");
 394 Clazz.defineMethod(c$,"clone",
 395 function(){
 396 var a=Clazz.superCall(this,java.util.concurrent.ConcurrentHashMap.Entry,"clone",[]);
 397 if(this.next!=null){
 398 a.next=this.next.clone();
 399 }return a;
 400 });
 401 c$=Clazz.p0p();
 402 Clazz.pu$h(self.c$);
 403 c$=Clazz.decorateAsClass(function(){
 404 this.position=0;
 405 this.expectedModCount=0;
 406 this.type=null;
 407 this.canRemove=false;
 408 this.entry=null;
 409 this.lastEntry=null;
 410 this.associatedMap=null;
 411 Clazz.instantialize(this,arguments);
 412 },java.util.concurrent.ConcurrentHashMap,"ConcurrentHashMapIterator",null,java.util.Iterator);
 413 Clazz.makeConstructor(c$,
 414 function(a,b){
 415 this.associatedMap=b;
 416 this.type=a;
 417 this.expectedModCount=b.modCount;
 418 },"java.util.MapEntry.Type,java.util.concurrent.ConcurrentHashMap");
 419 Clazz.overrideMethod(c$,"hasNext",
 420 function(){
 421 if(this.entry!=null){
 422 return true;
 423 }while(this.position<this.associatedMap.elementData.length){
 424 if(this.associatedMap.elementData[this.position]==null){
 425 this.position++;
 426 }else{
 427 return true;
 428 }}
 429 return false;
 430 });
 431 Clazz.defineMethod(c$,"checkConcurrentMod",
 432 function(){
 433 if(this.expectedModCount!=this.associatedMap.modCount){
 434 throw new java.util.ConcurrentModificationException();
 435 }});
 436 Clazz.overrideMethod(c$,"next",
 437 function(){
 438 this.checkConcurrentMod();
 439 if(!this.hasNext()){
 440 throw new java.util.NoSuchElementException();
 441 }var a;
 442 if(this.entry==null){
 443 a=this.lastEntry=this.associatedMap.elementData[this.position++];
 444 this.entry=this.lastEntry.next;
 445 }else{
 446 if(this.lastEntry.next!==this.entry){
 447 this.lastEntry=this.lastEntry.next;
 448 }a=this.entry;
 449 this.entry=this.entry.next;
 450 }this.canRemove=true;
 451 return this.type.get(a);
 452 });
 453 Clazz.overrideMethod(c$,"remove",
 454 function(){
 455 this.checkConcurrentMod();
 456 if(!this.canRemove){
 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){
 462 ;}
 463 this.associatedMap.elementData[this.position]=this.associatedMap.elementData[this.position].next;
 464 this.entry=null;
 465 }else{
 466 this.lastEntry.next=this.entry;
 467 }this.associatedMap.elementCount--;
 468 this.expectedModCount++;
 469 });
 470 c$=Clazz.p0p();
 471 Clazz.pu$h(self.c$);
 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$,
 477 function(a){
 478 Clazz.superConstructor(this,java.util.concurrent.ConcurrentHashMap.ConcurrentHashMapEntrySet,[]);
 479 this.associatedMap=a;
 480 },"java.util.concurrent.ConcurrentHashMap");
 481 Clazz.defineMethod(c$,"hashMap",
 482 function(){
 483 return this.associatedMap;
 484 });
 485 Clazz.overrideMethod(c$,"size",
 486 function(){
 487 return this.associatedMap.elementCount;
 488 });
 489 Clazz.overrideMethod(c$,"clear",
 490 function(){
 491 this.associatedMap.clear();
 492 });
 493 Clazz.overrideMethod(c$,"remove",
 494 function(a){
 495 if(this.contains(a)){
 496 this.associatedMap.remove((a).getKey());
 497 return true;
 498 }return false;
 499 },"~O");
 500 Clazz.overrideMethod(c$,"contains",
 501 function(a){
 502 if(Clazz.instanceOf(a,java.util.Map.Entry)){
 503 var b=this.associatedMap.getEntry((a).getKey());
 504 return a.equals(b);
 505 }return false;
 506 },"~O");
 507 Clazz.overrideMethod(c$,"iterator",
 508 function(){
 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);
 510 });
 511 c$.$ConcurrentHashMap$ConcurrentHashMapEntrySet$1$=function(){
 512 Clazz.pu$h(self.c$);
 513 c$=Clazz.declareAnonymous(java.util.concurrent,"ConcurrentHashMap$ConcurrentHashMapEntrySet$1",null,java.util.MapEntry.Type);
 514 Clazz.overrideMethod(c$,"get",
 515 function(a){
 516 return a;
 517 },"java.util.MapEntry");
 518 c$=Clazz.p0p();
 519 };
 520 c$=Clazz.p0p();
 521 Clazz.defineStatics(c$,
 522 "DEFAULT_SIZE",16);
 523 });