Mercurial Hosting > luan

comparison src/luan/lib/JavaLib.java @ 56:c84274b18f0c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
various git-svn-id: https://luan-java.googlecode.com/svn/trunk@57 21e917c8-12df-6dd8-5cb6-c86387c605b9
author fschmidt@gmail.com <fschmidt@gmail.com@21e917c8-12df-6dd8-5cb6-c86387c605b9>
date Fri, 04 Jan 2013 21:35:55 +0000
parents 9381b23ea9e1
children d6c454b7f58c
comparison
equal deleted inserted replaced
55:9381b23ea9e1 56:c84274b18f0c
79 } 79 }
80 return new AmbiguousJavaFunction(fns); 80 return new AmbiguousJavaFunction(fns);
81 } 81 }
82 } 82 }
83 } else { 83 } else {
84 List<AccessibleObject> members = getStaticMembers(cls,name); 84 List<Member> members = getStaticMembers(cls,name);
85 if( !members.isEmpty() ) { 85 if( !members.isEmpty() ) {
86 return member(null,members); 86 return member(null,members);
87 } 87 }
88 } 88 }
89 } 89 }
90 throw new LuanException(luan,LuanElement.JAVA,"invalid index for java class: "+key); 90 throw new LuanException(luan,LuanElement.JAVA,"invalid member '"+key+"' for: "+obj);
91 } 91 }
92 Class cls = obj.getClass(); 92 Class cls = obj.getClass();
93 if( cls.isArray() ) { 93 if( cls.isArray() ) {
94 if( "length".equals(key) ) { 94 if( "length".equals(key) ) {
95 return Array.getLength(obj); 95 return Array.getLength(obj);
96 } 96 }
97 Integer i = Luan.asInteger(key); 97 Integer i = Luan.asInteger(key);
98 if( i != null ) { 98 if( i != null ) {
99 return Array.get(obj,i); 99 return Array.get(obj,i);
100 } 100 }
101 throw new LuanException(luan,LuanElement.JAVA,"invalid index for java array: "+key); 101 throw new LuanException(luan,LuanElement.JAVA,"invalid member '"+key+"' for java array: "+obj);
102 } 102 }
103 if( key instanceof String ) { 103 if( key instanceof String ) {
104 String name = (String)key; 104 String name = (String)key;
105 if( "instanceof".equals(name) ) { 105 if( "instanceof".equals(name) ) {
106 return new LuanJavaFunction(instanceOf,new InstanceOf(obj)); 106 return new LuanJavaFunction(instanceOf,new InstanceOf(obj));
107 } else { 107 } else {
108 List<AccessibleObject> members = getMembers(cls,name); 108 List<Member> members = getMembers(cls,name);
109 if( !members.isEmpty() ) { 109 if( !members.isEmpty() ) {
110 return member(obj,members); 110 return member(obj,members);
111 } 111 }
112 } 112 }
113 } 113 }
114 throw new LuanException(luan,LuanElement.JAVA,"invalid member for java object: "+key); 114 throw new LuanException(luan,LuanElement.JAVA,"invalid member '"+key+"' for java object: "+obj);
115 } 115 }
116 116
117 private static Object member(Object obj,List<AccessibleObject> members) throws LuanException { 117 private static Object member(Object obj,List<Member> members) throws LuanException {
118 try { 118 try {
119 for( AccessibleObject m : members ) { 119 for( Member m : members ) {
120 m.setAccessible(true); 120 if( m instanceof AccessibleObject )
121 ((AccessibleObject)m).setAccessible(true);
121 } 122 }
122 if( members.size()==1 ) { 123 if( members.size()==1 ) {
123 AccessibleObject member = members.get(0); 124 Member member = members.get(0);
124 if( member instanceof Field ) { 125 if( member instanceof Static ) {
126 return member;
127 } else if( member instanceof Field ) {
125 Field field = (Field)member; 128 Field field = (Field)member;
126 return field.get(obj); 129 return field.get(obj);
127 } else { 130 } else {
128 Method method = (Method)member; 131 Method method = (Method)member;
129 return new LuanJavaFunction(method,obj); 132 return new LuanJavaFunction(method,obj);
130 } 133 }
131 } else { 134 } else {
132 List<LuanJavaFunction> fns = new ArrayList<LuanJavaFunction>(); 135 List<LuanJavaFunction> fns = new ArrayList<LuanJavaFunction>();
133 for( AccessibleObject member : members ) { 136 for( Member member : members ) {
134 Method method = (Method)member; 137 Method method = (Method)member;
135 fns.add(new LuanJavaFunction(method,obj)); 138 fns.add(new LuanJavaFunction(method,obj));
136 } 139 }
137 return new AmbiguousJavaFunction(fns); 140 return new AmbiguousJavaFunction(fns);
138 } 141 }
139 } catch(IllegalAccessException e) { 142 } catch(IllegalAccessException e) {
140 throw new RuntimeException(e); 143 throw new RuntimeException(e);
141 } 144 }
142 } 145 }
143 146
144 private static Map<Class,Map<String,List<AccessibleObject>>> memberMap = new HashMap<Class,Map<String,List<AccessibleObject>>>(); 147 private static Map<Class,Map<String,List<Member>>> memberMap = new HashMap<Class,Map<String,List<Member>>>();
145 148
146 private static synchronized List<AccessibleObject> getMembers(Class cls,String name) { 149 private static synchronized List<Member> getMembers(Class cls,String name) {
147 Map<String,List<AccessibleObject>> clsMap = memberMap.get(cls); 150 Map<String,List<Member>> clsMap = memberMap.get(cls);
148 if( clsMap == null ) { 151 if( clsMap == null ) {
149 clsMap = new HashMap<String,List<AccessibleObject>>(); 152 clsMap = new HashMap<String,List<Member>>();
153 for( Class c : cls.getClasses() ) {
154 String s = c.getSimpleName();
155 List<Member> list = clsMap.get(s);
156 if( list == null ) {
157 list = new ArrayList<Member>();
158 clsMap.put(s,list);
159 }
160 list.add(new Static(c));
161 }
150 for( Field field : cls.getFields() ) { 162 for( Field field : cls.getFields() ) {
151 String s = field.getName(); 163 String s = field.getName();
152 List<AccessibleObject> list = clsMap.get(s); 164 List<Member> list = clsMap.get(s);
153 if( list == null ) { 165 if( list == null ) {
154 list = new ArrayList<AccessibleObject>(); 166 list = new ArrayList<Member>();
155 clsMap.put(s,list); 167 clsMap.put(s,list);
156 } 168 }
157 list.add(field); 169 list.add(field);
158 } 170 }
159 for( Method method : cls.getMethods() ) { 171 for( Method method : cls.getMethods() ) {
160 String s = method.getName(); 172 String s = method.getName();
161 List<AccessibleObject> list = clsMap.get(s); 173 List<Member> list = clsMap.get(s);
162 if( list == null ) { 174 if( list == null ) {
163 list = new ArrayList<AccessibleObject>(); 175 list = new ArrayList<Member>();
164 clsMap.put(s,list); 176 clsMap.put(s,list);
165 } 177 }
166 list.add(method); 178 list.add(method);
167 } 179 }
168 memberMap.put(cls,clsMap); 180 memberMap.put(cls,clsMap);
169 } 181 }
170 List<AccessibleObject> rtn = clsMap.get(name); 182 List<Member> rtn = clsMap.get(name);
171 if( rtn==null ) 183 if( rtn==null )
172 rtn = Collections.emptyList(); 184 rtn = Collections.emptyList();
173 return rtn; 185 return rtn;
174 } 186 }
175 187
176 private static synchronized List<AccessibleObject> getStaticMembers(Class cls,String name) { 188 private static synchronized List<Member> getStaticMembers(Class cls,String name) {
177 List<AccessibleObject> staticMembers = new ArrayList<AccessibleObject>(); 189 List<Member> staticMembers = new ArrayList<Member>();
178 for( AccessibleObject m : getMembers(cls,name) ) { 190 for( Member m : getMembers(cls,name) ) {
179 if( Modifier.isStatic(((Member)m).getModifiers()) ) 191 if( Modifier.isStatic(m.getModifiers()) )
180 staticMembers.add(m); 192 staticMembers.add(m);
181 } 193 }
182 return staticMembers; 194 return staticMembers;
183 } 195 }
184 196
185 static class Static { 197 static final class Static implements Member {
186 final Class cls; 198 final Class cls;
187 199
188 Static(Class cls) { 200 Static(Class cls) {
189 this.cls = cls; 201 this.cls = cls;
202 }
203
204 @Override public String toString() {
205 return cls.toString();
206 }
207
208 @Override public Class<?> getDeclaringClass() {
209 return cls.getDeclaringClass();
210 }
211
212 @Override public String getName() {
213 return cls.getName();
214 }
215
216 @Override public int getModifiers() {
217 return cls.getModifiers();
218 }
219
220 @Override public boolean isSynthetic() {
221 return cls.isSynthetic();
190 } 222 }
191 } 223 }
192 224
193 public static Static getClass(LuanState luan,String name) throws LuanException { 225 public static Static getClass(LuanState luan,String name) throws LuanException {
194 Class cls; 226 Class cls;