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

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