site/j2s/java/util/LinkedHashMap.js

   1 Clazz.load(["java.util.HashMap"],"java.util.LinkedHashMap",["java.lang.IllegalStateException","java.util.AbstractCollection","$.AbstractSet","java.util.MapEntry.Type","java.util.NoSuchElementException"],function(){
   2 c$=Clazz.decorateAsClass(function(){
   3 this.accessOrder=false;
   4 this.head=null;
   5 this.tail=null;
   6 Clazz.instantialize(this,arguments);
   7 },java.util,"LinkedHashMap",java.util.HashMap);
   8 Clazz.makeConstructor(c$,
   9 function(){
  10 Clazz.superConstructor(this,java.util.LinkedHashMap);
  11 this.accessOrder=false;
  12 this.head=null;
  13 });
  14 Clazz.makeConstructor(c$,
  15 function(s){
  16 Clazz.superConstructor(this,java.util.LinkedHashMap,[s]);
  17 this.accessOrder=false;
  18 this.head=null;
  19 },"~N");
  20 Clazz.makeConstructor(c$,
  21 function(s,lf){
  22 Clazz.superConstructor(this,java.util.LinkedHashMap,[s,lf]);
  23 this.accessOrder=false;
  24 this.head=null;
  25 this.tail=null;
  26 },"~N,~N");
  27 Clazz.makeConstructor(c$,
  28 function(s,lf,order){
  29 Clazz.superConstructor(this,java.util.LinkedHashMap,[s,lf]);
  30 this.accessOrder=order;
  31 this.head=null;
  32 this.tail=null;
  33 },"~N,~N,~B");
  34 Clazz.makeConstructor(c$,
  35 function(m){
  36 Clazz.superConstructor(this,java.util.LinkedHashMap,[]);
  37 this.accessOrder=false;
  38 this.head=null;
  39 this.tail=null;
  40 this.putAll(m);
  41 },"java.util.Map");
  42 Clazz.overrideMethod(c$,"newElementArray",
  43 function(s){
  44 return new Array(s);
  45 },"~N");
  46 Clazz.overrideMethod(c$,"get",
  47 function(key){
  48 var m=this.getEntry(key);
  49 if(m==null){
  50 return null;
  51 }if(this.accessOrder&&this.tail!==m){
  52 var p=m.chainBackward;
  53 var n=m.chainForward;
  54 n.chainBackward=p;
  55 if(p!=null){
  56 p.chainForward=n;
  57 }else{
  58 this.head=n;
  59 }m.chainForward=null;
  60 m.chainBackward=this.tail;
  61 this.tail.chainForward=m;
  62 this.tail=m;
  63 }return m.value;
  64 },"~O");
  65 Clazz.overrideMethod(c$,"createEntry",
  66 function(key,index,value){
  67 var m=new java.util.LinkedHashMap.LinkedHashMapEntry(key,value);
  68 m.next=this.elementData[index];
  69 this.elementData[index]=m;
  70 this.linkEntry(m);
  71 return m;
  72 },"~O,~N,~O");
  73 Clazz.overrideMethod(c$,"put",
  74 function(key,value){
  75 var index=this.getModuloHash(key);
  76 var m=this.findEntry(key,index);
  77 if(m==null){
  78 this.modCount++;
  79 if(++this.elementCount>this.threshold){
  80 this.rehash();
  81 index=key==null?0:(key.hashCode()&0x7FFFFFFF)%this.elementData.length;
  82 }m=this.createEntry(key,index,null);
  83 }else{
  84 this.linkEntry(m);
  85 }var result=m.value;
  86 m.value=value;
  87 if(this.removeEldestEntry(this.head)){
  88 this.remove(this.head.key);
  89 }return result;
  90 },"~O,~O");
  91 Clazz.defineMethod(c$,"linkEntry",
  92 function(m){
  93 if(this.tail===m){
  94 return;
  95 }if(this.head==null){
  96 this.head=this.tail=m;
  97 return;
  98 }var p=m.chainBackward;
  99 var n=m.chainForward;
 100 if(p==null){
 101 if(n!=null){
 102 if(this.accessOrder){
 103 this.head=n;
 104 n.chainBackward=null;
 105 m.chainBackward=this.tail;
 106 m.chainForward=null;
 107 this.tail.chainForward=m;
 108 this.tail=m;
 109 }}else{
 110 m.chainBackward=this.tail;
 111 m.chainForward=null;
 112 this.tail.chainForward=m;
 113 this.tail=m;
 114 }return;
 115 }if(n==null){
 116 return;
 117 }if(this.accessOrder){
 118 p.chainForward=n;
 119 n.chainBackward=p;
 120 m.chainForward=null;
 121 m.chainBackward=this.tail;
 122 this.tail.chainForward=m;
 123 this.tail=m;
 124 }},"java.util.LinkedHashMap.LinkedHashMapEntry");
 125 Clazz.overrideMethod(c$,"entrySet",
 126 function(){
 127 return new java.util.LinkedHashMap.LinkedHashMapEntrySet(this);
 128 });
 129 Clazz.overrideMethod(c$,"keySet",
 130 function(){
 131 if(this.$keySet==null){
 132 this.$keySet=((Clazz.isClassDefined("java.util.LinkedHashMap$1")?0:java.util.LinkedHashMap.$LinkedHashMap$1$()),Clazz.innerTypeInstance(java.util.LinkedHashMap$1,this,null));
 133 }return this.$keySet;
 134 });
 135 Clazz.overrideMethod(c$,"values",
 136 function(){
 137 if(this.valuesCollection==null){
 138 this.valuesCollection=((Clazz.isClassDefined("java.util.LinkedHashMap$2")?0:java.util.LinkedHashMap.$LinkedHashMap$2$()),Clazz.innerTypeInstance(java.util.LinkedHashMap$2,this,null));
 139 }return this.valuesCollection;
 140 });
 141 Clazz.overrideMethod(c$,"remove",
 142 function(key){
 143 var m=this.removeEntry(key);
 144 if(m==null){
 145 return null;
 146 }var p=m.chainBackward;
 147 var n=m.chainForward;
 148 if(p!=null){
 149 p.chainForward=n;
 150 }else{
 151 this.head=n;
 152 }if(n!=null){
 153 n.chainBackward=p;
 154 }else{
 155 this.tail=p;
 156 }return m.value;
 157 },"~O");
 158 Clazz.defineMethod(c$,"removeEldestEntry",
 159 function(eldest){
 160 return false;
 161 },"java.util.Map.Entry");
 162 Clazz.defineMethod(c$,"clear",
 163 function(){
 164 Clazz.superCall(this,java.util.LinkedHashMap,"clear",[]);
 165 this.head=this.tail=null;
 166 });
 167 Clazz.defineMethod(c$,"clone",
 168 function(){
 169 var map=Clazz.superCall(this,java.util.LinkedHashMap,"clone",[]);
 170 map.clear();
 171 for(var entry,$entry=this.entrySet().iterator();$entry.hasNext()&&((entry=$entry.next())||true);){
 172 map.put(entry.getKey(),entry.getValue());
 173 }
 174 return map;
 175 });
 176 c$.$LinkedHashMap$1$=function(){
 177 Clazz.pu$h(self.c$);
 178 c$=Clazz.declareAnonymous(java.util,"LinkedHashMap$1",java.util.AbstractSet);
 179 Clazz.overrideMethod(c$,"contains",
 180 function(object){
 181 return this.b$["java.util.LinkedHashMap"].containsKey(object);
 182 },"~O");
 183 Clazz.overrideMethod(c$,"size",
 184 function(){
 185 return this.b$["java.util.LinkedHashMap"].size();
 186 });
 187 Clazz.overrideMethod(c$,"clear",
 188 function(){
 189 this.b$["java.util.LinkedHashMap"].clear();
 190 });
 191 Clazz.overrideMethod(c$,"remove",
 192 function(key){
 193 if(this.b$["java.util.LinkedHashMap"].containsKey(key)){
 194 this.b$["java.util.LinkedHashMap"].remove(key);
 195 return true;
 196 }return false;
 197 },"~O");
 198 Clazz.overrideMethod(c$,"iterator",
 199 function(){
 200 return new java.util.LinkedHashMap.LinkedHashIterator(((Clazz.isClassDefined("java.util.LinkedHashMap$1$1")?0:java.util.LinkedHashMap.$LinkedHashMap$1$1$()),Clazz.innerTypeInstance(java.util.LinkedHashMap$1$1,this,null)),this.b$["java.util.LinkedHashMap"]);
 201 });
 202 c$=Clazz.p0p();
 203 };
 204 c$.$LinkedHashMap$1$1$=function(){
 205 Clazz.pu$h(self.c$);
 206 c$=Clazz.declareAnonymous(java.util,"LinkedHashMap$1$1",null,java.util.MapEntry.Type);
 207 Clazz.overrideMethod(c$,"get",
 208 function(entry){
 209 return entry.key;
 210 },"java.util.MapEntry");
 211 c$=Clazz.p0p();
 212 };
 213 c$.$LinkedHashMap$2$=function(){
 214 Clazz.pu$h(self.c$);
 215 c$=Clazz.declareAnonymous(java.util,"LinkedHashMap$2",java.util.AbstractCollection);
 216 Clazz.overrideMethod(c$,"contains",
 217 function(object){
 218 return this.b$["java.util.LinkedHashMap"].containsValue(object);
 219 },"~O");
 220 Clazz.overrideMethod(c$,"size",
 221 function(){
 222 return this.b$["java.util.LinkedHashMap"].size();
 223 });
 224 Clazz.overrideMethod(c$,"clear",
 225 function(){
 226 this.b$["java.util.LinkedHashMap"].clear();
 227 });
 228 Clazz.overrideMethod(c$,"iterator",
 229 function(){
 230 return new java.util.LinkedHashMap.LinkedHashIterator(((Clazz.isClassDefined("java.util.LinkedHashMap$2$1")?0:java.util.LinkedHashMap.$LinkedHashMap$2$1$()),Clazz.innerTypeInstance(java.util.LinkedHashMap$2$1,this,null)),this.b$["java.util.LinkedHashMap"]);
 231 });
 232 c$=Clazz.p0p();
 233 };
 234 c$.$LinkedHashMap$2$1$=function(){
 235 Clazz.pu$h(self.c$);
 236 c$=Clazz.declareAnonymous(java.util,"LinkedHashMap$2$1",null,java.util.MapEntry.Type);
 237 Clazz.overrideMethod(c$,"get",
 238 function(entry){
 239 return entry.value;
 240 },"java.util.MapEntry");
 241 c$=Clazz.p0p();
 242 };
 243 Clazz.pu$h(self.c$);
 244 c$=Clazz.declareType(java.util.LinkedHashMap,"LinkedHashIterator",java.util.HashMap.HashMapIterator);
 245 Clazz.makeConstructor(c$,
 246 function(a,b){
 247 Clazz.superConstructor(this,java.util.LinkedHashMap.LinkedHashIterator,[a,b]);
 248 this.entry=b.head;
 249 },"java.util.MapEntry.Type,java.util.LinkedHashMap");
 250 Clazz.overrideMethod(c$,"hasNext",
 251 function(){
 252 return(this.entry!=null);
 253 });
 254 Clazz.overrideMethod(c$,"next",
 255 function(){
 256 this.checkConcurrentMod();
 257 if(!this.hasNext()){
 258 throw new java.util.NoSuchElementException();
 259 }var a=this.type.get(this.entry);
 260 this.lastEntry=this.entry;
 261 this.entry=(this.entry).chainForward;
 262 this.canRemove=true;
 263 return a;
 264 });
 265 Clazz.overrideMethod(c$,"remove",
 266 function(){
 267 this.checkConcurrentMod();
 268 if(!this.canRemove){
 269 throw new IllegalStateException();
 270 }this.canRemove=false;
 271 this.associatedMap.modCount++;
 272 var a=this.associatedMap.getModuloHash(this.lastEntry.key);
 273 var b=this.associatedMap.elementData[a];
 274 if(b===this.lastEntry){
 275 this.associatedMap.elementData[a]=this.lastEntry.next;
 276 }else{
 277 while(b.next!=null){
 278 if(b.next===this.lastEntry){
 279 break;
 280 }b=b.next;
 281 }
 282 b.next=this.lastEntry.next;
 283 }var c=this.lastEntry;
 284 var d=c.chainBackward;
 285 var e=c.chainForward;
 286 var f=this.associatedMap;
 287 if(d!=null){
 288 d.chainForward=e;
 289 if(e!=null){
 290 e.chainBackward=d;
 291 }else{
 292 f.tail=d;
 293 }}else{
 294 f.head=e;
 295 if(e!=null){
 296 e.chainBackward=null;
 297 }else{
 298 f.tail=null;
 299 }}this.associatedMap.elementCount--;
 300 this.expectedModCount++;
 301 });
 302 c$=Clazz.p0p();
 303 Clazz.pu$h(self.c$);
 304 c$=Clazz.declareType(java.util.LinkedHashMap,"LinkedHashMapEntrySet",java.util.HashMap.HashMapEntrySet);
 305 Clazz.overrideMethod(c$,"iterator",
 306 function(){
 307 return new java.util.LinkedHashMap.LinkedHashIterator(((Clazz.isClassDefined("java.util.LinkedHashMap$LinkedHashMapEntrySet$1")?0:java.util.LinkedHashMap.LinkedHashMapEntrySet.$LinkedHashMap$LinkedHashMapEntrySet$1$()),Clazz.innerTypeInstance(java.util.LinkedHashMap$LinkedHashMapEntrySet$1,this,null)),this.hashMap());
 308 });
 309 c$.$LinkedHashMap$LinkedHashMapEntrySet$1$=function(){
 310 Clazz.pu$h(self.c$);
 311 c$=Clazz.declareAnonymous(java.util,"LinkedHashMap$LinkedHashMapEntrySet$1",null,java.util.MapEntry.Type);
 312 Clazz.overrideMethod(c$,"get",
 313 function(a){
 314 return a;
 315 },"java.util.MapEntry");
 316 c$=Clazz.p0p();
 317 };
 318 c$=Clazz.p0p();
 319 Clazz.pu$h(self.c$);
 320 c$=Clazz.decorateAsClass(function(){
 321 this.chainForward=null;
 322 this.chainBackward=null;
 323 Clazz.instantialize(this,arguments);
 324 },java.util.LinkedHashMap,"LinkedHashMapEntry",java.util.HashMap.Entry);
 325 Clazz.makeConstructor(c$,
 326 function(a,b){
 327 Clazz.superConstructor(this,java.util.LinkedHashMap.LinkedHashMapEntry,[a,b]);
 328 this.chainForward=null;
 329 this.chainBackward=null;
 330 },"~O,~O");
 331 Clazz.defineMethod(c$,"clone",
 332 function(){
 333 var a=Clazz.superCall(this,java.util.LinkedHashMap.LinkedHashMapEntry,"clone",[]);
 334 a.chainBackward=this.chainBackward;
 335 a.chainForward=this.chainForward;
 336 var b=a.next;
 337 if(b!=null){
 338 a.next=b.clone();
 339 }return a;
 340 });
 341 c$=Clazz.p0p();
 342 });