1 /*
2 * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.script.javascript;
27
28 import sun.org.mozilla.javascript.internal.*;
29 import java.util.*;
30
31 /**
32 * JSAdapter is java.lang.reflect.Proxy equivalent for JavaScript. JSAdapter
33 * calls specially named JavaScript methods on an adaptee object when property
34 * access is attempted on it.
35 *
36 * Example:
37 *
38 * var y = {
39 * __get__ : function (name) { ... }
40 * __has__ : function (name) { ... }
41 * __put__ : function (name, value) {...}
42 * __delete__ : function (name) { ... }
43 * __getIds__ : function () { ... }
44 * };
45 *
46 * var x = new JSAdapter(y);
47 *
48 * x.i; // calls y.__get__
49 * i in x; // calls y.__has__
50 * x.p = 10; // calls y.__put__
51 * delete x.p; // calls y.__delete__
52 * for (i in x) { print(i); } // calls y.__getIds__
53 *
54 * If a special JavaScript method is not found in the adaptee, then JSAdapter
55 * forwards the property access to the adaptee itself.
56 *
57 * JavaScript caller of adapter object is isolated from the fact that
58 * the property access/mutation/deletion are really calls to
59 * JavaScript methods on adaptee. Use cases include 'smart'
60 * properties, property access tracing/debugging, encaptulation with
61 * easy client access - in short JavaScript becomes more "Self" like.
62 *
63 * Note that Rhino already supports special properties like __proto__
64 * (to set, get prototype), __parent__ (to set, get parent scope). We
65 * follow the same double underscore nameing convention here. Similarly
66 * the name JSAdapter is derived from JavaAdapter -- which is a facility
67 * to extend, implement Java classes/interfaces by JavaScript.
68 *
69 * @author A. Sundararajan
70 * @since 1.6
71 */
72 public final class JSAdapter implements Scriptable, Function {
73 private JSAdapter(Scriptable obj) {
74 setAdaptee(obj);
75 }
76
77 // initializer to setup JSAdapter prototype in the given scope
78 public static void init(Context cx, Scriptable scope, boolean sealed)
79 throws RhinoException {
80 JSAdapter obj = new JSAdapter(cx.newObject(scope));
81 obj.setParentScope(scope);
82 obj.setPrototype(getFunctionPrototype(scope));
83 obj.isPrototype = true;
84 ScriptableObject.defineProperty(scope, "JSAdapter", obj,
85 ScriptableObject.DONTENUM);
86 }
87
88 public String getClassName() {
89 return "JSAdapter";
90 }
91
92 public Object get(String name, Scriptable start) {
93 Function func = getAdapteeFunction(GET_PROP);
94 if (func != null) {
95 return call(func, new Object[] { name });
96 } else {
97 start = getAdaptee();
98 return start.get(name, start);
99 }
100 }
101
102 public Object get(int index, Scriptable start) {
103 Function func = getAdapteeFunction(GET_PROP);
104 if (func != null) {
105 return call(func, new Object[] { new Integer(index) });
106 } else {
107 start = getAdaptee();
108 return start.get(index, start);
109 }
110 }
111
112 public boolean has(String name, Scriptable start) {
113 Function func = getAdapteeFunction(HAS_PROP);
114 if (func != null) {
115 Object res = call(func, new Object[] { name });
116 return Context.toBoolean(res);
117 } else {
118 start = getAdaptee();
119 return start.has(name, start);
120 }
121 }
122
123 public boolean has(int index, Scriptable start) {
124 Function func = getAdapteeFunction(HAS_PROP);
125 if (func != null) {
126 Object res = call(func, new Object[] { new Integer(index) });
127 return Context.toBoolean(res);
128 } else {
129 start = getAdaptee();
130 return start.has(index, start);
131 }
132 }
133
134 public void put(String name, Scriptable start, Object value) {
135 if (start == this) {
136 Function func = getAdapteeFunction(PUT_PROP);
137 if (func != null) {
138 call(func, new Object[] { name, value });
139 } else {
140 start = getAdaptee();
141 start.put(name, start, value);
142 }
143 } else {
144 start.put(name, start, value);
145 }
146 }
147
148 public void put(int index, Scriptable start, Object value) {
149 if (start == this) {
150 Function func = getAdapteeFunction(PUT_PROP);
151 if( func != null) {
152 call(func, new Object[] { new Integer(index), value });
153 } else {
154 start = getAdaptee();
155 start.put(index, start, value);
156 }
157 } else {
158 start.put(index, start, value);
159 }
160 }
161
162 public void delete(String name) {
163 Function func = getAdapteeFunction(DEL_PROP);
164 if (func != null) {
165 call(func, new Object[] { name });
166 } else {
167 getAdaptee().delete(name);
168 }
169 }
170
171 public void delete(int index) {
172 Function func = getAdapteeFunction(DEL_PROP);
173 if (func != null) {
174 call(func, new Object[] { new Integer(index) });
175 } else {
176 getAdaptee().delete(index);
177 }
178 }
179
180 public Scriptable getPrototype() {
181 return prototype;
182 }
183
184 public void setPrototype(Scriptable prototype) {
185 this.prototype = prototype;
186 }
187
188 public Scriptable getParentScope() {
189 return parent;
190 }
191
192 public void setParentScope(Scriptable parent) {
193 this.parent = parent;
194 }
195
196 public Object[] getIds() {
197 Function func = getAdapteeFunction(GET_PROPIDS);
198 if (func != null) {
199 Object val = call(func, new Object[0]);
200 // in most cases, adaptee would return native JS array
201 if (val instanceof NativeArray) {
202 NativeArray array = (NativeArray) val;
203 Object[] res = new Object[(int)array.getLength()];
204 for (int index = 0; index < res.length; index++) {
205 res[index] = mapToId(array.get(index, array));
206 }
207 return res;
208 } else if (val instanceof NativeJavaArray) {
209 // may be attempt wrapped Java array
210 Object tmp = ((NativeJavaArray)val).unwrap();
211 Object[] res;
212 if (tmp.getClass() == Object[].class) {
213 Object[] array = (Object[]) tmp;
214 res = new Object[array.length];
215 for (int index = 0; index < array.length; index++) {
216 res[index] = mapToId(array[index]);
217 }
218 } else {
219 // just return an empty array
220 res = Context.emptyArgs;
221 }
222 return res;
223 } else {
224 // some other return type, just return empty array
225 return Context.emptyArgs;
226 }
227 } else {
228 return getAdaptee().getIds();
229 }
230 }
231
232 public boolean hasInstance(Scriptable scriptable) {
233 if (scriptable instanceof JSAdapter) {
234 return true;
235 } else {
236 Scriptable proto = scriptable.getPrototype();
237 while (proto != null) {
238 if (proto.equals(this)) return true;
239 proto = proto.getPrototype();
240 }
241 return false;
242 }
243 }
244
245 public Object getDefaultValue(Class hint) {
246 return getAdaptee().getDefaultValue(hint);
247 }
248
249 public Object call(Context cx, Scriptable scope, Scriptable thisObj,
250 Object[] args)
251 throws RhinoException {
252 if (isPrototype) {
253 return construct(cx, scope, args);
254 } else {
255 Scriptable tmp = getAdaptee();
256 if (tmp instanceof Function) {
257 return ((Function)tmp).call(cx, scope, tmp, args);
258 } else {
259 throw Context.reportRuntimeError("TypeError: not a function");
260 }
261 }
262 }
263
264 public Scriptable construct(Context cx, Scriptable scope, Object[] args)
265 throws RhinoException {
266 if (isPrototype) {
267 Scriptable topLevel = ScriptableObject.getTopLevelScope(scope);
268 JSAdapter newObj;
269 if (args.length > 0) {
270 newObj = new JSAdapter(Context.toObject(args[0], topLevel));
271 } else {
272 throw Context.reportRuntimeError("JSAdapter requires adaptee");
273 }
274 return newObj;
275 } else {
276 Scriptable tmp = getAdaptee();
277 if (tmp instanceof Function) {
278 return ((Function)tmp).construct(cx, scope, args);
279 } else {
280 throw Context.reportRuntimeError("TypeError: not a constructor");
281 }
282 }
283 }
284
285 public Scriptable getAdaptee() {
286 return adaptee;
287 }
288
289 public void setAdaptee(Scriptable adaptee) {
290 if (adaptee == null) {
291 throw new NullPointerException("adaptee can not be null");
292 }
293 this.adaptee = adaptee;
294 }
295
296 //-- internals only below this point
297
298 // map a property id. Property id can only be an Integer or String
299 private Object mapToId(Object tmp) {
300 if (tmp instanceof Double) {
301 return new Integer(((Double)tmp).intValue());
302 } else {
303 return Context.toString(tmp);
304 }
305 }
306
307 private static Scriptable getFunctionPrototype(Scriptable scope) {
308 return ScriptableObject.getFunctionPrototype(scope);
309 }
310
311 private Function getAdapteeFunction(String name) {
312 Object o = ScriptableObject.getProperty(getAdaptee(), name);
313 return (o instanceof Function)? (Function)o : null;
314 }
315
316 private Object call(Function func, Object[] args) {
317 Context cx = Context.getCurrentContext();
318 Scriptable thisObj = getAdaptee();
319 Scriptable scope = func.getParentScope();
320 try {
321 return func.call(cx, scope, thisObj, args);
322 } catch (RhinoException re) {
323 throw Context.reportRuntimeError(re.getMessage());
324 }
325 }
326
327 private Scriptable prototype;
328 private Scriptable parent;
329 private Scriptable adaptee;
330 private boolean isPrototype;
331
332 // names of adaptee JavaScript functions
333 private static final String GET_PROP = "__get__";
334 private static final String HAS_PROP = "__has__";
335 private static final String PUT_PROP = "__put__";
336 private static final String DEL_PROP = "__delete__";
337 private static final String GET_PROPIDS = "__getIds__";
338 }