site/swingjs/j2s/java/util/IdentityHashMap.js

   1 Clazz.load(["java.util.AbstractMap","$.AbstractSet","$.Iterator","$.Map","$.MapEntry"],"java.util.IdentityHashMap",["java.lang.IllegalArgumentException","$.IllegalStateException","java.util.AbstractCollection","$.ConcurrentModificationException","java.util.MapEntry.Type","java.util.NoSuchElementException"],function(){
   2 c$=Clazz.decorateAsClass(function(){
   3 this.elementData=null;
   4 this.$size=0;
   5 this.threshold=0;
   6 this.modCount=0;
   7 Clazz.instantialize(this,arguments);
   8 },java.util,"IdentityHashMap",java.util.AbstractMap,[java.util.Map,java.io.Serializable,Cloneable]);
   9 Clazz.makeConstructor(c$,
  10 function(){
  11 this.construct(21);
  12 });
  13 Clazz.makeConstructor(c$,
  14 function(maxSize){
  15 Clazz.superConstructor(this,java.util.IdentityHashMap,[]);
  16 if(maxSize>=0){
  17 this.$size=0;
  18 this.threshold=this.getThreshold(maxSize);
  19 this.elementData=this.newElementArray(this.computeElementArraySize());
  20 }else{
  21 throw new IllegalArgumentException();
  22 }},"~N");
  23 Clazz.defineMethod(c$,"getThreshold",
  24 ($fz=function(maxSize){
  25 return maxSize>3?maxSize:3;
  26 },$fz.isPrivate=true,$fz),"~N");
  27 Clazz.defineMethod(c$,"computeElementArraySize",
  28 ($fz=function(){
  29 return(Math.floor((this.threshold*10000)/7500))*2;
  30 },$fz.isPrivate=true,$fz));
  31 Clazz.defineMethod(c$,"newElementArray",
  32 ($fz=function(s){
  33 return new Array(s);
  34 },$fz.isPrivate=true,$fz),"~N");
  35 Clazz.makeConstructor(c$,
  36 function(map){
  37 this.construct(map.size()<6?11:map.size()*2);
  38 this.putAllImpl(map);
  39 },"java.util.Map");
  40 Clazz.defineMethod(c$,"massageValue",
  41 ($fz=function(value){
  42 return((value===java.util.IdentityHashMap.NULL_OBJECT)?null:value);
  43 },$fz.isPrivate=true,$fz),"~O");
  44 Clazz.overrideMethod(c$,"clear",
  45 function(){
  46 this.$size=0;
  47 for(var i=0;i<this.elementData.length;i++){
  48 this.elementData[i]=null;
  49 }
  50 this.modCount++;
  51 });
  52 Clazz.overrideMethod(c$,"containsKey",
  53 function(key){
  54 if(key==null){
  55 key=java.util.IdentityHashMap.NULL_OBJECT;
  56 }var index=this.findIndex(key,this.elementData);
  57 return this.elementData[index]===key;
  58 },"~O");
  59 Clazz.overrideMethod(c$,"containsValue",
  60 function(value){
  61 if(value==null){
  62 value=java.util.IdentityHashMap.NULL_OBJECT;
  63 }for(var i=1;i<this.elementData.length;i=i+2){
  64 if(this.elementData[i]===value){
  65 return true;
  66 }}
  67 return false;
  68 },"~O");
  69 Clazz.overrideMethod(c$,"get",
  70 function(key){
  71 if(key==null){
  72 key=java.util.IdentityHashMap.NULL_OBJECT;
  73 }var index=this.findIndex(key,this.elementData);
  74 if(this.elementData[index]===key){
  75 var result=this.elementData[index+1];
  76 return this.massageValue(result);
  77 }return null;
  78 },"~O");
  79 Clazz.defineMethod(c$,"getEntry",
  80 ($fz=function(key){
  81 if(key==null){
  82 key=java.util.IdentityHashMap.NULL_OBJECT;
  83 }var index=this.findIndex(key,this.elementData);
  84 if(this.elementData[index]===key){
  85 return this.getEntry(index);
  86 }return null;
  87 },$fz.isPrivate=true,$fz),"~O");
  88 Clazz.defineMethod(c$,"getEntry",
  89 ($fz=function(index){
  90 var key=this.elementData[index];
  91 var value=this.elementData[index+1];
  92 if(key===java.util.IdentityHashMap.NULL_OBJECT){
  93 key=null;
  94 }if(value===java.util.IdentityHashMap.NULL_OBJECT){
  95 value=null;
  96 }return new java.util.IdentityHashMap.IdentityHashMapEntry(key,value);
  97 },$fz.isPrivate=true,$fz),"~N");
  98 Clazz.defineMethod(c$,"findIndex",
  99 ($fz=function(key,array){
 100 var length=array.length;
 101 var index=this.getModuloHash(key,length);
 102 var last=(index+length-2)%length;
 103 while(index!=last){
 104 if(array[index]===key||(array[index]==null)){
 105 break;
 106 }index=(index+2)%length;
 107 }
 108 return index;
 109 },$fz.isPrivate=true,$fz),"~O,~A");
 110 Clazz.defineMethod(c$,"getModuloHash",
 111 ($fz=function(key,length){
 112 return((System.identityHashCode(key)&0x7FFFFFFF)%(Math.floor(length/2)))*2;
 113 },$fz.isPrivate=true,$fz),"~O,~N");
 114 Clazz.overrideMethod(c$,"put",
 115 function(key,value){
 116 var _key=key;
 117 var _value=value;
 118 if(_key==null){
 119 _key=java.util.IdentityHashMap.NULL_OBJECT;
 120 }if(_value==null){
 121 _value=java.util.IdentityHashMap.NULL_OBJECT;
 122 }var index=this.findIndex(_key,this.elementData);
 123 if(this.elementData[index]!==_key){
 124 this.modCount++;
 125 if(++this.$size>this.threshold){
 126 this.rehash();
 127 index=this.findIndex(_key,this.elementData);
 128 }this.elementData[index]=_key;
 129 this.elementData[index+1]=null;
 130 }var result=this.elementData[index+1];
 131 this.elementData[index+1]=_value;
 132 return this.massageValue(result);
 133 },"~O,~O");
 134 Clazz.overrideMethod(c$,"putAll",
 135 function(map){
 136 this.putAllImpl(map);
 137 },"java.util.Map");
 138 Clazz.defineMethod(c$,"rehash",
 139 ($fz=function(){
 140 var newlength=this.elementData.length<<1;
 141 if(newlength==0){
 142 newlength=1;
 143 }var newData=this.newElementArray(newlength);
 144 for(var i=0;i<this.elementData.length;i=i+2){
 145 var key=this.elementData[i];
 146 if(key!=null){
 147 var index=this.findIndex(key,newData);
 148 newData[index]=key;
 149 newData[index+1]=this.elementData[i+1];
 150 }}
 151 this.elementData=newData;
 152 this.computeMaxSize();
 153 },$fz.isPrivate=true,$fz));
 154 Clazz.defineMethod(c$,"computeMaxSize",
 155 ($fz=function(){
 156 this.threshold=(Math.floor((Math.floor(this.elementData.length/ 2)) * 7500 /10000));
 157 },$fz.isPrivate=true,$fz));
 158 Clazz.overrideMethod(c$,"remove",
 159 function(key){
 160 if(key==null){
 161 key=java.util.IdentityHashMap.NULL_OBJECT;
 162 }var hashedOk;
 163 var index;
 164 var next;
 165 var hash;
 166 var result;
 167 var object;
 168 index=next=this.findIndex(key,this.elementData);
 169 if(this.elementData[index]!==key){
 170 return null;
 171 }result=this.elementData[index+1];
 172 var length=this.elementData.length;
 173 while(true){
 174 next=(next+2)%length;
 175 object=this.elementData[next];
 176 if(object==null){
 177 break;
 178 }hash=this.getModuloHash(object,length);
 179 hashedOk=hash>index;
 180 if(next<index){
 181 hashedOk=hashedOk||(hash<=next);
 182 }else{
 183 hashedOk=hashedOk&&(hash<=next);
 184 }if(!hashedOk){
 185 this.elementData[index]=object;
 186 this.elementData[index+1]=this.elementData[next+1];
 187 index=next;
 188 }}
 189 this.$size--;
 190 this.modCount++;
 191 this.elementData[index]=null;
 192 this.elementData[index+1]=null;
 193 return this.massageValue(result);
 194 },"~O");
 195 Clazz.overrideMethod(c$,"entrySet",
 196 function(){
 197 return new java.util.IdentityHashMap.IdentityHashMapEntrySet(this);
 198 });
 199 Clazz.overrideMethod(c$,"keySet",
 200 function(){
 201 if(this.$keySet==null){
 202 this.$keySet=((Clazz.isClassDefined("java.util.IdentityHashMap$1")?0:java.util.IdentityHashMap.$IdentityHashMap$1$()),Clazz.innerTypeInstance(java.util.IdentityHashMap$1,this,null));
 203 }return this.$keySet;
 204 });
 205 Clazz.overrideMethod(c$,"values",
 206 function(){
 207 if(this.valuesCollection==null){
 208 this.valuesCollection=((Clazz.isClassDefined("java.util.IdentityHashMap$2")?0:java.util.IdentityHashMap.$IdentityHashMap$2$()),Clazz.innerTypeInstance(java.util.IdentityHashMap$2,this,null));
 209 }return this.valuesCollection;
 210 });
 211 Clazz.overrideMethod(c$,"equals",
 212 function(object){
 213 if(this===object){
 214 return true;
 215 }if(Clazz.instanceOf(object,java.util.Map)){
 216 var map=object;
 217 if(this.size()!=map.size()){
 218 return false;
 219 }var set=this.entrySet();
 220 return set.equals(map.entrySet());
 221 }return false;
 222 },"~O");
 223 Clazz.defineMethod(c$,"clone",
 224 function(){
 225 try{
 226 return Clazz.superCall(this,java.util.IdentityHashMap,"clone",[]);
 227 }catch(e){
 228 if(Clazz.instanceOf(e,CloneNotSupportedException)){
 229 return null;
 230 }else{
 231 throw e;
 232 }
 233 }
 234 });
 235 Clazz.overrideMethod(c$,"isEmpty",
 236 function(){
 237 return this.$size==0;
 238 });
 239 Clazz.overrideMethod(c$,"size",
 240 function(){
 241 return this.$size;
 242 });
 243 Clazz.defineMethod(c$,"putAllImpl",
 244 ($fz=function(map){
 245 if(map.entrySet()!=null){
 246 Clazz.superCall(this,java.util.IdentityHashMap,"putAll",[map]);
 247 }},$fz.isPrivate=true,$fz),"java.util.Map");
 248 c$.$IdentityHashMap$1$=function(){
 249 Clazz.pu$h(self.c$);
 250 c$=Clazz.declareAnonymous(java.util,"IdentityHashMap$1",java.util.AbstractSet);
 251 Clazz.overrideMethod(c$,"contains",
 252 function(object){
 253 return this.b$["java.util.IdentityHashMap"].containsKey(object);
 254 },"~O");
 255 Clazz.overrideMethod(c$,"size",
 256 function(){
 257 return this.b$["java.util.IdentityHashMap"].size();
 258 });
 259 Clazz.overrideMethod(c$,"clear",
 260 function(){
 261 this.b$["java.util.IdentityHashMap"].clear();
 262 });
 263 Clazz.overrideMethod(c$,"remove",
 264 function(key){
 265 if(this.b$["java.util.IdentityHashMap"].containsKey(key)){
 266 this.b$["java.util.IdentityHashMap"].remove(key);
 267 return true;
 268 }return false;
 269 },"~O");
 270 Clazz.overrideMethod(c$,"iterator",
 271 function(){
 272 return new java.util.IdentityHashMap.IdentityHashMapIterator(((Clazz.isClassDefined("java.util.IdentityHashMap$1$1")?0:java.util.IdentityHashMap.$IdentityHashMap$1$1$()),Clazz.innerTypeInstance(java.util.IdentityHashMap$1$1,this,null)),this.b$["java.util.IdentityHashMap"]);
 273 });
 274 c$=Clazz.p0p();
 275 };
 276 c$.$IdentityHashMap$1$1$=function(){
 277 Clazz.pu$h(self.c$);
 278 c$=Clazz.declareAnonymous(java.util,"IdentityHashMap$1$1",null,java.util.MapEntry.Type);
 279 Clazz.overrideMethod(c$,"get",
 280 function(entry){
 281 return entry.key;
 282 },"java.util.MapEntry");
 283 c$=Clazz.p0p();
 284 };
 285 c$.$IdentityHashMap$2$=function(){
 286 Clazz.pu$h(self.c$);
 287 c$=Clazz.declareAnonymous(java.util,"IdentityHashMap$2",java.util.AbstractCollection);
 288 Clazz.overrideMethod(c$,"contains",
 289 function(object){
 290 return this.b$["java.util.IdentityHashMap"].containsValue(object);
 291 },"~O");
 292 Clazz.overrideMethod(c$,"size",
 293 function(){
 294 return this.b$["java.util.IdentityHashMap"].size();
 295 });
 296 Clazz.overrideMethod(c$,"clear",
 297 function(){
 298 this.b$["java.util.IdentityHashMap"].clear();
 299 });
 300 Clazz.overrideMethod(c$,"iterator",
 301 function(){
 302 return new java.util.IdentityHashMap.IdentityHashMapIterator(((Clazz.isClassDefined("java.util.IdentityHashMap$2$1")?0:java.util.IdentityHashMap.$IdentityHashMap$2$1$()),Clazz.innerTypeInstance(java.util.IdentityHashMap$2$1,this,null)),this.b$["java.util.IdentityHashMap"]);
 303 });
 304 Clazz.overrideMethod(c$,"remove",
 305 function(object){
 306 var it=this.iterator();
 307 while(it.hasNext()){
 308 if(object===it.next()){
 309 it.remove();
 310 return true;
 311 }}
 312 return false;
 313 },"~O");
 314 c$=Clazz.p0p();
 315 };
 316 c$.$IdentityHashMap$2$1$=function(){
 317 Clazz.pu$h(self.c$);
 318 c$=Clazz.declareAnonymous(java.util,"IdentityHashMap$2$1",null,java.util.MapEntry.Type);
 319 Clazz.overrideMethod(c$,"get",
 320 function(entry){
 321 return entry.value;
 322 },"java.util.MapEntry");
 323 c$=Clazz.p0p();
 324 };
 325 Clazz.pu$h(self.c$);
 326 c$=Clazz.declareType(java.util.IdentityHashMap,"IdentityHashMapEntry",java.util.MapEntry);
 327 Clazz.overrideMethod(c$,"equals",
 328 function(a){
 329 if(this===a){
 330 return true;
 331 }if(Clazz.instanceOf(a,java.util.Map.Entry)){
 332 var b=a;
 333 return(this.key===b.getKey())&&(this.value===b.getValue());
 334 }return false;
 335 },"~O");
 336 Clazz.overrideMethod(c$,"hashCode",
 337 function(){
 338 return System.identityHashCode(this.key)^System.identityHashCode(this.value);
 339 });
 340 Clazz.overrideMethod(c$,"toString",
 341 function(){
 342 return this.key+"="+this.value;
 343 });
 344 c$=Clazz.p0p();
 345 Clazz.pu$h(self.c$);
 346 c$=Clazz.decorateAsClass(function(){
 347 this.position=0;
 348 this.lastPosition=0;
 349 this.associatedMap=null;
 350 this.expectedModCount=0;
 351 this.type=null;
 352 this.canRemove=false;
 353 Clazz.instantialize(this,arguments);
 354 },java.util.IdentityHashMap,"IdentityHashMapIterator",null,java.util.Iterator);
 355 Clazz.makeConstructor(c$,
 356 function(a,b){
 357 this.associatedMap=b;
 358 this.type=a;
 359 this.expectedModCount=b.modCount;
 360 },"java.util.MapEntry.Type,java.util.IdentityHashMap");
 361 Clazz.overrideMethod(c$,"hasNext",
 362 function(){
 363 while(this.position<this.associatedMap.elementData.length){
 364 if(this.associatedMap.elementData[this.position]==null){
 365 this.position+=2;
 366 }else{
 367 return true;
 368 }}
 369 return false;
 370 });
 371 Clazz.defineMethod(c$,"checkConcurrentMod",
 372 function(){
 373 if(this.expectedModCount!=this.associatedMap.modCount){
 374 throw new java.util.ConcurrentModificationException();
 375 }});
 376 Clazz.overrideMethod(c$,"next",
 377 function(){
 378 this.checkConcurrentMod();
 379 if(!this.hasNext()){
 380 throw new java.util.NoSuchElementException();
 381 }var a=this.associatedMap.getEntry(this.position);
 382 this.lastPosition=this.position;
 383 this.position+=2;
 384 this.canRemove=true;
 385 return this.type.get(a);
 386 });
 387 Clazz.overrideMethod(c$,"remove",
 388 function(){
 389 this.checkConcurrentMod();
 390 if(!this.canRemove){
 391 throw new IllegalStateException();
 392 }this.canRemove=false;
 393 this.associatedMap.remove(this.associatedMap.elementData[this.lastPosition]);
 394 this.position=this.lastPosition;
 395 this.expectedModCount++;
 396 });
 397 c$=Clazz.p0p();
 398 Clazz.pu$h(self.c$);
 399 c$=Clazz.decorateAsClass(function(){
 400 this.associatedMap=null;
 401 Clazz.instantialize(this,arguments);
 402 },java.util.IdentityHashMap,"IdentityHashMapEntrySet",java.util.AbstractSet);
 403 Clazz.makeConstructor(c$,
 404 function(a){
 405 Clazz.superConstructor(this,java.util.IdentityHashMap.IdentityHashMapEntrySet,[]);
 406 this.associatedMap=a;
 407 },"java.util.IdentityHashMap");
 408 Clazz.defineMethod(c$,"hashMap",
 409 function(){
 410 return this.associatedMap;
 411 });
 412 Clazz.overrideMethod(c$,"size",
 413 function(){
 414 return this.associatedMap.$size;
 415 });
 416 Clazz.overrideMethod(c$,"clear",
 417 function(){
 418 this.associatedMap.clear();
 419 });
 420 Clazz.overrideMethod(c$,"remove",
 421 function(a){
 422 if(this.contains(a)){
 423 this.associatedMap.remove((a).getKey());
 424 return true;
 425 }return false;
 426 },"~O");
 427 Clazz.overrideMethod(c$,"contains",
 428 function(a){
 429 if(Clazz.instanceOf(a,java.util.Map.Entry)){
 430 var b=this.associatedMap.getEntry((a).getKey());
 431 return b!=null&&b.equals(a);
 432 }return false;
 433 },"~O");
 434 Clazz.overrideMethod(c$,"iterator",
 435 function(){
 436 return new java.util.IdentityHashMap.IdentityHashMapIterator(((Clazz.isClassDefined("java.util.IdentityHashMap$IdentityHashMapEntrySet$1")?0:java.util.IdentityHashMap.IdentityHashMapEntrySet.$IdentityHashMap$IdentityHashMapEntrySet$1$()),Clazz.innerTypeInstance(java.util.IdentityHashMap$IdentityHashMapEntrySet$1,this,null)),this.associatedMap);
 437 });
 438 c$.$IdentityHashMap$IdentityHashMapEntrySet$1$=function(){
 439 Clazz.pu$h(self.c$);
 440 c$=Clazz.declareAnonymous(java.util,"IdentityHashMap$IdentityHashMapEntrySet$1",null,java.util.MapEntry.Type);
 441 Clazz.overrideMethod(c$,"get",
 442 function(a){
 443 return a;
 444 },"java.util.MapEntry");
 445 c$=Clazz.p0p();
 446 };
 447 c$=Clazz.p0p();
 448 Clazz.defineStatics(c$,
 449 "DEFAULT_MAX_SIZE",21,
 450 "loadFactor",7500);
 451 c$.NULL_OBJECT=c$.prototype.NULL_OBJECT=new Clazz._O();
 452 });