KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > caucho > quercus > env > JavaValue


1 /*
2  * Copyright (c) 1998-2006 Caucho Technology -- all rights reserved
3  *
4  * This file is part of Resin(R) Open Source
5  *
6  * Each copy or derived work must preserve the copyright notice and this
7  * notice unmodified.
8  *
9  * Resin Open Source is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * Resin Open Source is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
17  * of NON-INFRINGEMENT. See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Resin Open Source; if not, write to the
22  *
23  * Free Software Foundation, Inc.
24  * 59 Temple Place, Suite 330
25  * Boston, MA 02111-1307 USA
26  *
27  * @author Scott Ferguson
28  */
29
30 package com.caucho.quercus.env;
31
32 import com.caucho.quercus.expr.Expr;
33 import com.caucho.quercus.program.AbstractFunction;
34 import com.caucho.quercus.program.JavaClassDef;
35 import com.caucho.vfs.ContextLoaderObjectInputStream;
36 import com.caucho.vfs.WriteStream;
37
38 import java.io.IOException JavaDoc;
39 import java.io.InputStream JavaDoc;
40 import java.io.ObjectInputStream JavaDoc;
41 import java.io.ObjectOutputStream JavaDoc;
42 import java.io.Serializable JavaDoc;
43 import java.util.IdentityHashMap JavaDoc;
44 import java.util.Map JavaDoc;
45 import java.util.logging.Logger JavaDoc;
46
47 /**
48  * Represents a Quercus java value.
49  */
50 public class JavaValue extends ResourceValue
51   implements Serializable JavaDoc
52 {
53   private static final Logger JavaDoc log
54     = Logger.getLogger(JavaValue.class.getName());
55   
56   private JavaClassDef _classDef;
57
58   private Object JavaDoc _object;
59
60   protected Env _env;
61
62   public JavaValue(Env env, Object JavaDoc object, JavaClassDef def)
63   {
64     if (object == null)
65       throw new NullPointerException JavaDoc();
66     
67     _env = env;
68     _classDef = def;
69     _object = object;
70   }
71
72   public String JavaDoc getClassName()
73   {
74     return _classDef.getName();
75   }
76
77   @Override JavaDoc
78   protected void printRImpl(Env env,
79                             WriteStream out,
80                             int depth,
81                             IdentityHashMap JavaDoc<Value, String JavaDoc> valueSet)
82     throws IOException JavaDoc
83   {
84     // if (! _classDef.printRImpl(env, _object, out, depth, valueSet))
85 super.printRImpl(env, out, depth, valueSet);
86   }
87   
88   @Override JavaDoc
89   protected void varDumpImpl(Env env,
90                             WriteStream out,
91                             int depth,
92                             IdentityHashMap JavaDoc<Value, String JavaDoc> valueSet)
93     throws IOException JavaDoc
94   {
95     if (!_classDef.varDumpImpl(env, _object, out, depth, valueSet))
96       super.varDumpImpl(env, out, depth, valueSet);
97   }
98   
99   @Override JavaDoc
100   public Value get(Value name)
101   {
102     return _classDef.get(_env, _object, name);
103   }
104
105   @Override JavaDoc
106   public Value put(Value index, Value value)
107   {
108     return _classDef.put(_env, _object, index, value);
109   }
110
111   @Override JavaDoc
112   public Value getField(Env env, String JavaDoc name)
113   {
114     return _classDef.getField(env, _object, name);
115   }
116
117   @Override JavaDoc
118   public Value putField(Env env,
119                         String JavaDoc name,
120                         Value value)
121   {
122     return _classDef.putField(env, _object, name, value);
123   }
124
125   /**
126    * Returns the class name.
127    */
128   public String JavaDoc getName()
129   {
130     return _classDef.getName();
131   }
132
133   /**
134    * Returns the type.
135    */
136   public String JavaDoc getType()
137   {
138     return "object";
139   }
140
141   /**
142    * Converts to a boolean.
143    */
144   public boolean toBoolean()
145   {
146     return true;
147   }
148
149   /**
150    * Converts to a long.
151    */
152   public long toLong()
153   {
154     return 1;
155   }
156
157   /**
158    * Converts to a double.
159    */
160   public double toDouble()
161   {
162     return toLong();
163   }
164
165   /**
166    * Converts to a key.
167    */
168   public Value toKey()
169   {
170     return new LongValue(System.identityHashCode(this));
171   }
172
173   public boolean isA(String JavaDoc name)
174   {
175     return _classDef.isA(name);
176   }
177
178   /**
179    * Returns the method.
180    */
181   public AbstractFunction findFunction(String JavaDoc methodName)
182   {
183     return _classDef.findFunction(methodName);
184   }
185
186   /**
187    * Evaluates a method.
188    */
189   public Value callMethod(Env env, String JavaDoc methodName, Expr []args)
190   {
191     return _classDef.callMethod(env, _object, methodName, args);
192   }
193
194   /**
195    * Evaluates a method.
196    */
197   public Value callMethod(Env env, String JavaDoc methodName, Value []args)
198   {
199     return _classDef.callMethod(env, _object, methodName, args);
200   }
201
202   /**
203    * Evaluates a method.
204    */
205   public Value callMethod(Env env, String JavaDoc methodName)
206   {
207     return _classDef.callMethod(env, _object, methodName);
208   }
209
210   /**
211    * Evaluates a method.
212    */
213   public Value callMethod(Env env, String JavaDoc methodName, Value a1)
214   {
215     return _classDef.callMethod(env, _object, methodName, a1);
216   }
217
218   /**
219    * Evaluates a method.
220    */
221   public Value callMethod(Env env, String JavaDoc methodName, Value a1, Value a2)
222   {
223     return _classDef.callMethod(env, _object, methodName, a1, a2);
224   }
225
226   /**
227    * Evaluates a method.
228    */
229   public Value callMethod(Env env, String JavaDoc methodName,
230                           Value a1, Value a2, Value a3)
231   {
232     return _classDef.callMethod(env, _object, methodName, a1, a2, a3);
233   }
234
235   /**
236    * Evaluates a method.
237    */
238   public Value callMethod(Env env, String JavaDoc methodName,
239                           Value a1, Value a2, Value a3, Value a4)
240   {
241     return _classDef.callMethod(env, _object, methodName, a1, a2, a3, a4);
242   }
243
244   /**
245    * Evaluates a method.
246    */
247   public Value callMethod(Env env, String JavaDoc methodName,
248                           Value a1, Value a2, Value a3, Value a4, Value a5)
249   {
250     return _classDef.callMethod(env, _object, methodName, a1, a2, a3, a4, a5);
251   }
252
253   /**
254    * Evaluates a method.
255    */
256   public Value callMethodRef(Env env, String JavaDoc methodName, Expr []args)
257   {
258     return _classDef.callMethod(env, _object, methodName, args);
259   }
260
261   /**
262    * Evaluates a method.
263    */
264   public Value callMethodRef(Env env, String JavaDoc methodName, Value []args)
265   {
266     return _classDef.callMethod(env, _object, methodName, args);
267   }
268
269   /**
270    * Evaluates a method.
271    */
272   public Value callMethodRef(Env env, String JavaDoc methodName)
273   {
274     return _classDef.callMethod(env, _object, methodName);
275   }
276
277   /**
278    * Evaluates a method.
279    */
280   public Value callMethodRef(Env env, String JavaDoc methodName, Value a1)
281   {
282     return _classDef.callMethod(env, _object, methodName, a1);
283   }
284
285   /**
286    * Evaluates a method.
287    */
288   public Value callMethodRef(Env env, String JavaDoc methodName, Value a1, Value a2)
289   {
290     return _classDef.callMethod(env, _object, methodName, a1, a2);
291   }
292
293   /**
294    * Evaluates a method.
295    */
296   public Value callMethodRef(Env env, String JavaDoc methodName,
297                           Value a1, Value a2, Value a3)
298   {
299     return _classDef.callMethod(env, _object, methodName, a1, a2, a3);
300   }
301
302   /**
303    * Evaluates a method.
304    */
305   public Value callMethodRef(Env env, String JavaDoc methodName,
306                           Value a1, Value a2, Value a3, Value a4)
307   {
308     return _classDef.callMethod(env, _object, methodName, a1, a2, a3, a4);
309   }
310
311   /**
312    * Evaluates a method.
313    */
314   public Value callMethodRef(Env env, String JavaDoc methodName,
315                           Value a1, Value a2, Value a3, Value a4, Value a5)
316   {
317     return _classDef.callMethod(env, _object, methodName, a1, a2, a3, a4, a5);
318   }
319
320   /**
321    * Returns the iterator values.
322    */
323   public Value []getValueArray(Env env)
324   {
325     return _classDef.getValueArray(env, _object);
326   }
327
328   /**
329    * Serializes the value.
330    */
331   public void serialize(StringBuilder JavaDoc sb)
332   {
333     log.fine("Quercus: can't serialize " + _object.getClass());
334
335     sb.append("N;");
336   }
337
338   /**
339    * Converts to a string.
340    */
341   public String JavaDoc toString()
342   {
343     // php/1x0b
344 return String.valueOf(_object);
345   }
346
347
348   /**
349    * Converts to an object.
350    */
351   @Override JavaDoc
352   public Object JavaDoc toJavaObject()
353   {
354     return _object;
355   }
356
357   /**
358    * Converts to a java object.
359    */
360   @Override JavaDoc
361   public Object JavaDoc toJavaObject(Env env, Class JavaDoc type)
362   {
363     if (type.isAssignableFrom(_object.getClass())) {
364       return _object;
365     } else {
366       env.warning(L.l("Can't assign {0} to {1}",
367               _object.getClass().getName(), type.getName()));
368     
369       return null;
370     }
371   }
372
373   /**
374    * Converts to a java object.
375    */
376   @Override JavaDoc
377   public Object JavaDoc toJavaObjectNotNull(Env env, Class JavaDoc type)
378   {
379     if (type.isAssignableFrom(_object.getClass())) {
380       return _object;
381     } else {
382       env.warning(L.l("Can't assign {0} to {1}",
383               _object.getClass().getName(), type.getName()));
384     
385       return null;
386     }
387   }
388
389   /**
390    * Converts to a java object.
391    */
392   @Override JavaDoc
393   public Map JavaDoc toJavaMap(Env env, Class JavaDoc type)
394   {
395     if (type.isAssignableFrom(_object.getClass())) {
396       return (Map JavaDoc) _object;
397     } else {
398       env.warning(L.l("Can't assign {0} to {1}",
399               _object.getClass().getName(), type.getName()));
400     
401       return null;
402     }
403   }
404
405   /**
406    * Converts to an object.
407    */
408   @Override JavaDoc
409   public InputStream toInputStream()
410   {
411     if (_object instanceof InputStream)
412       return (InputStream) _object;
413     else
414       return super.toInputStream();
415   }
416
417   //
418 // Java Serialization
419 //
420
421   private void writeObject(ObjectOutputStream JavaDoc out)
422     throws IOException JavaDoc
423   {
424     out.writeObject(_classDef.getType().getCanonicalName());
425     
426     out.writeObject(_object);
427   }
428
429   private void readObject(ObjectInputStream in)
430     throws ClassNotFoundException JavaDoc, IOException JavaDoc
431   {
432     _env = Env.getInstance();
433     
434     _classDef = _env.getJavaClassDefinition((String JavaDoc) in.readObject());
435     
436     _object = in.readObject();
437   }
438 }
439
440
Popular Tags