Mercurial Hosting > luan

comparison src/luan/LuanTable.java @ 1562:b89212fd04b5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
remove table.luan
author Franklin Schmidt <fschmidt@gmail.com>
date Sun, 08 Nov 2020 16:50:59 -0700
parents e1a13e707bf3
children 8fbcc4747091
comparison
equal deleted inserted replaced
1561:e1a13e707bf3 1562:b89212fd04b5
12 import java.util.Set; 12 import java.util.Set;
13 import java.util.HashSet; 13 import java.util.HashSet;
14 14
15 15
16 public final class LuanTable implements LuanCloneable { 16 public final class LuanTable implements LuanCloneable {
17 private Luan luan;
18 private Map map = null; 17 private Map map = null;
19 private List list = null; 18 private List list = null;
20 private LuanTable metatable = null; 19 private LuanTable metatable = null;
21 public LuanClosure closure; 20 public LuanClosure closure;
22 private LuanCloner cloner; 21 private LuanCloner cloner;
23 private String security = null;
24 private boolean immutable = false; 22 private boolean immutable = false;
25 23
26 public LuanTable(Luan luan) { 24 public LuanTable() {}
27 this.luan = luan; 25
28 } 26 public LuanTable(List list) {
29 27 try {
30 public LuanTable(Luan luan,List list) { 28 list();
31 this.luan = luan; 29 int n = list.size();
32 list(); 30 for( int i=0; i<n; i++ ) {
33 int n = list.size(); 31 Object val = list.get(i);
34 for( int i=0; i<n; i++ ) { 32 if( val != null )
35 Object val = list.get(i); 33 rawPut(i+1,val);
36 if( val != null ) 34 }
37 rawPut2(i+1,val); 35 } catch(LuanException e) {
38 } 36 throw new RuntimeException(e);
39 } 37 }
40 38 }
41 public LuanTable(Luan luan,Map map) { 39
42 this.luan = luan; 40 public LuanTable(Map map) {
43 for( Object stupid : map.entrySet() ) { 41 try {
44 Map.Entry entry = (Map.Entry)stupid; 42 for( Object stupid : map.entrySet() ) {
45 Object key = entry.getKey(); 43 Map.Entry entry = (Map.Entry)stupid;
46 Object value = entry.getValue(); 44 Object key = entry.getKey();
47 if( key != null && value != null ) 45 Object value = entry.getValue();
48 rawPut2(key,value); 46 if( key != null && value != null )
49 } 47 rawPut(key,value);
50 } 48 }
51 49 } catch(LuanException e) {
52 public LuanTable(Luan luan,Set set) { 50 throw new RuntimeException(e);
53 this.luan = luan; 51 }
54 for( Object el : set ) { 52 }
55 if( el != null ) 53
56 rawPut2(el,Boolean.TRUE); 54 public LuanTable(Set set) {
55 try {
56 for( Object el : set ) {
57 if( el != null )
58 rawPut(el,Boolean.TRUE);
59 }
60 } catch(LuanException e) {
61 throw new RuntimeException(e);
57 } 62 }
58 } 63 }
59 64
60 public LuanTable(LuanTable tbl) { 65 public LuanTable(LuanTable tbl) {
61 this.luan = tbl.luan;
62 if( tbl.map != null && !tbl.map.isEmpty() ) 66 if( tbl.map != null && !tbl.map.isEmpty() )
63 this.map = new LinkedHashMap<Object,Object>(tbl.map); 67 this.map = new LinkedHashMap<Object,Object>(tbl.map);
64 if( tbl.rawLength() > 0 ) 68 if( tbl.rawLength() > 0 )
65 this.list = new ArrayList<Object>(tbl.list); 69 this.list = new ArrayList<Object>(tbl.list);
66 this.metatable = tbl.metatable; 70 this.metatable = tbl.metatable;
67 } 71 }
68 72
69 @Override public LuanTable shallowClone() { 73 @Override public LuanTable shallowClone() {
70 if(immutable) throw new RuntimeException(); 74 if(immutable) throw new RuntimeException();
71 return new LuanTable(luan); 75 return new LuanTable();
72 } 76 }
73 77
74 @Override public void deepenClone(LuanCloneable dc,LuanCloner cloner) { 78 @Override public void deepenClone(LuanCloneable dc,LuanCloner cloner) {
75 check(); 79 check();
76 LuanTable clone = (LuanTable)dc; 80 LuanTable clone = (LuanTable)dc;
77 clone.security = security;
78 switch( cloner.type ) { 81 switch( cloner.type ) {
79 case COMPLETE: 82 case COMPLETE:
80 completeClone(clone,cloner); 83 completeClone(clone,cloner);
81 return; 84 return;
82 case INCREMENTAL: 85 case INCREMENTAL:
94 completeClone(this,cloner); 97 completeClone(this,cloner);
95 cloner = null; 98 cloner = null;
96 } 99 }
97 } 100 }
98 101
99 public Luan luan() {
100 check();
101 return luan;
102 }
103
104 private void completeClone(LuanTable clone,LuanCloner cloner) { 102 private void completeClone(LuanTable clone,LuanCloner cloner) {
105 clone.luan = (Luan)cloner.clone(luan);
106 clone.map = cloner.clone(map); 103 clone.map = cloner.clone(map);
107 clone.list = (List)cloner.clone(list); 104 clone.list = (List)cloner.clone(list);
108 clone.metatable = (LuanTable)cloner.clone(metatable); 105 clone.metatable = (LuanTable)cloner.clone(metatable);
109 clone.closure = (LuanClosure)cloner.clone(closure); 106 clone.closure = (LuanClosure)cloner.clone(closure);
110 } 107 }
111 108
112 @Override public void makeImmutable(LuanImmutabler immutabler) throws LuanException { 109 @Override public void makeImmutable(LuanImmutabler immutabler) throws LuanException {
113 check(); 110 check();
114 immutabler.makeImmutable(luan);
115 immutabler.makeImmutable(map); 111 immutabler.makeImmutable(map);
116 immutabler.makeImmutable(list); 112 immutabler.makeImmutable(list);
117 immutabler.makeImmutable(metatable); 113 immutabler.makeImmutable(metatable);
118 immutabler.makeImmutable(closure); 114 immutabler.makeImmutable(closure);
119 immutable = true; 115 immutable = true;
147 143
148 public String rawToString() { 144 public String rawToString() {
149 return "table: " + Integer.toHexString(hashCode()); 145 return "table: " + Integer.toHexString(hashCode());
150 } 146 }
151 147
152 public Object get(Object key) throws LuanException { 148 public Object get(Luan luan,Object key) throws LuanException {
153 Object value = rawGet(key); 149 Object value = rawGet(key);
154 if( value != null ) 150 if( value != null )
155 return value; 151 return value;
156 Object h = getHandler("__index"); 152 Object h = getHandler("__index");
157 if( h==null ) 153 if( h==null )
180 key = Double.valueOf(n.doubleValue()); 176 key = Double.valueOf(n.doubleValue());
181 } 177 }
182 return map.get(key); 178 return map.get(key);
183 } 179 }
184 180
185 public void put(Object key,Object value) throws LuanException { 181 public void put(Luan luan,Object key,Object value) throws LuanException {
186 Object h = getHandler("__new_index"); 182 Object h = getHandler("__new_index");
187 if( h==null || rawGet(key)!=null ) { 183 if( h==null || rawGet(key)!=null ) {
188 rawPut(key,value); 184 rawPut(key,value);
189 return; 185 return;
190 } 186 }
193 fn.call(this,key,value); 189 fn.call(this,key,value);
194 return; 190 return;
195 } 191 }
196 if( h instanceof LuanTable ) { 192 if( h instanceof LuanTable ) {
197 LuanTable tbl = (LuanTable)h; 193 LuanTable tbl = (LuanTable)h;
198 tbl.put(key,value); 194 tbl.put(luan,key,value);
199 return; 195 return;
200 } 196 }
201 throw new LuanException("invalid type "+Luan.type(h)+" for metamethod __new_index"); 197 throw new LuanException("invalid type "+Luan.type(h)+" for metamethod __new_index");
202 } 198 }
203 199
204 public Object rawPut(Object key,Object val) throws LuanException { 200 public Object rawPut(Object key,Object val) throws LuanException {
205 if( immutable ) 201 if( immutable )
206 throw new LuanException("table is immutable"); 202 throw new LuanException("table is immutable");
207 if( security != null )
208 Luan.checkSecurity(luan,"table",security,"put",key,val);
209 return rawPut2(key,val);
210 }
211
212 private Object rawPut2(Object key,Object val) {
213 check(); 203 check();
214 Integer iT = Luan.asInteger(key); 204 Integer iT = Luan.asInteger(key);
215 if( iT != null ) { 205 if( iT != null ) {
216 int i = iT - 1; 206 int i = iT - 1;
217 if( list != null || i == 0 ) { 207 if( list != null || i == 0 ) {
456 }; 446 };
457 } 447 }
458 448
459 public LuanTable rawSubList(int from,int to) { 449 public LuanTable rawSubList(int from,int to) {
460 check(); 450 check();
461 LuanTable tbl = new LuanTable(luan); 451 LuanTable tbl = new LuanTable();
462 tbl.list = new ArrayList<Object>(list().subList(from-1,to-1)); 452 tbl.list = new ArrayList<Object>(list().subList(from-1,to-1));
463 return tbl; 453 return tbl;
464 } 454 }
465 455
466 public LuanTable getMetatable() { 456 public LuanTable getMetatable() {
467 check(); 457 check();
468 return metatable; 458 return metatable;
469 } 459 }
470 460
471 public void setMetatable(LuanTable metatable) throws LuanException { 461 public void setMetatable(LuanTable metatable) throws LuanException {
472 if( security != null )
473 Luan.checkSecurity(luan,"table",security,"set_metatable",metatable);
474 check(); 462 check();
475 this.metatable = metatable; 463 this.metatable = metatable;
476 } 464 }
477 465
478 public Object getHandler(String op) throws LuanException { 466 public Object getHandler(String op) throws LuanException {
479 check(); 467 check();
480 return metatable==null ? null : metatable.get(op); 468 return metatable==null ? null : metatable.rawGet(op);
481 } 469 }
482 470
483 private static Map<Object,Object> newMap() { 471 private static Map<Object,Object> newMap() {
484 return new LinkedHashMap<Object,Object>(); 472 return new LinkedHashMap<Object,Object>();
485 } 473 }
538 526
539 public Object remove(Object key) throws LuanException { 527 public Object remove(Object key) throws LuanException {
540 if( immutable ) 528 if( immutable )
541 throw new LuanException("table is immutable"); 529 throw new LuanException("table is immutable");
542 Object old = rawGet(key); 530 Object old = rawGet(key);
543 rawPut2(key,null); 531 rawPut(key,null);
544 return old; 532 return old;
545 } 533 }
546 534
547 protected void finalize() throws Throwable { 535 protected void finalize() throws Throwable {
548 Object h = getHandler("__gc"); 536 Object h = getHandler("__gc");
551 fn.call(this); 539 fn.call(this);
552 } 540 }
553 super.finalize(); 541 super.finalize();
554 } 542 }
555 543
556 public LuanFunction fn(String fnName) throws LuanException { 544 public LuanFunction fn(Luan luan,String fnName) throws LuanException {
557 return (LuanFunction)get(fnName); 545 return (LuanFunction)get(luan,fnName);
558 }
559
560 public static void setSecurity(LuanTable tbl,String security) {
561 tbl.security = security;
562 } 546 }
563 547
564 public static void debug(LuanTable table) { 548 public static void debug(LuanTable table) {
565 System.out.println("isMap "+table.isMap()); 549 System.out.println("isMap "+table.isMap());
566 } 550 }