001: /* Copyright (C) 2004 - 2007 db4objects Inc. http://www.db4o.com
002:
003: This file is part of the db4o open source object database.
004:
005: db4o is free software; you can redistribute it and/or modify it under
006: the terms of version 2 of the GNU General Public License as published
007: by the Free Software Foundation and as clarified by db4objects' GPL
008: interpretation policy, available at
009: http://www.db4o.com/about/company/legalpolicies/gplinterpretation/
010: Alternatively you can write to db4objects, Inc., 1900 S Norfolk Street,
011: Suite 350, San Mateo, CA 94403, USA.
012:
013: db4o is distributed in the hope that it will be useful, but WITHOUT ANY
014: WARRANTY; without even the implied warranty of MERCHANTABILITY or
015: FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
016: for more details.
017:
018: You should have received a copy of the GNU General Public License along
019: with this program; if not, write to the Free Software Foundation, Inc.,
020: 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
021: package com.db4o.reflect.jdk;
022:
023: import com.db4o.reflect.*;
024:
025: /**
026: * db4o wrapper for JDK reflector functionality
027: * @see com.db4o.ext.ExtObjectContainer#reflector()
028: * @see com.db4o.reflect.generic.GenericReflector
029: */
030: public class JdkReflector implements Reflector {
031:
032: private final JdkLoader _classLoader;
033: private Reflector _parent;
034: private ReflectArray _array;
035:
036: /**
037: * Constructor
038: * @param classLoader class loader
039: */
040: public JdkReflector(ClassLoader classLoader) {
041: this (new ClassLoaderJdkLoader(classLoader));
042: }
043:
044: /**
045: * Constructor
046: * @param classLoader class loader
047: */
048: public JdkReflector(JdkLoader classLoader) {
049: _classLoader = classLoader;
050: }
051:
052: /**
053: * ReflectArray factory
054: * @return ReflectArray instance
055: */
056: public ReflectArray array() {
057: if (_array == null) {
058: _array = new JdkArray(_parent);
059: }
060: return _array;
061: }
062:
063: /**
064: * Method stub
065: * @return true
066: */
067: public boolean constructorCallsSupported() {
068: return true;
069: }
070:
071: /**
072: * Creates a copy of the object
073: * @param obj object to copy
074: * @return object copy
075: */
076: public Object deepClone(Object obj) {
077: return new JdkReflector(_classLoader);
078: }
079:
080: /**
081: * Returns ReflectClass for the specified class
082: * @param clazz class
083: * @return ReflectClass for the specified class
084: */
085: public ReflectClass forClass(Class clazz) {
086: return new JdkClass(_parent, clazz);
087: }
088:
089: /**
090: * Returns ReflectClass for the specified class name
091: * @param className class name
092: * @return ReflectClass for the specified class name
093: */
094: public ReflectClass forName(String className) {
095: Class clazz = _classLoader.loadClass(className);
096: if (clazz == null) {
097: return null;
098: }
099: return new JdkClass(_parent, clazz);
100: }
101:
102: /**
103: * Returns ReflectClass for the specified class object
104: * @param a_object class object
105: * @return ReflectClass for the specified class object
106: */
107: public ReflectClass forObject(Object a_object) {
108: if (a_object == null) {
109: return null;
110: }
111: return _parent.forClass(a_object.getClass());
112: }
113:
114: /**
115: * Method stub. Returns false.
116: */
117: public boolean isCollection(ReflectClass candidate) {
118: return false;
119: }
120:
121: /**
122: * Method stub. Returns false.
123: */
124: public boolean methodCallsSupported() {
125: return true;
126: }
127:
128: /**
129: * Sets parent reflector
130: * @param reflector parent reflector
131: */
132: public void setParent(Reflector reflector) {
133: _parent = reflector;
134: }
135:
136: /**
137: * Creates ReflectClass[] array from the Class[]
138: * array using the reflector specified
139: * @param reflector reflector to use
140: * @param clazz class
141: * @return ReflectClass[] array
142: */
143: public static ReflectClass[] toMeta(Reflector reflector,
144: Class[] clazz) {
145: ReflectClass[] claxx = null;
146: if (clazz != null) {
147: claxx = new ReflectClass[clazz.length];
148: for (int i = 0; i < clazz.length; i++) {
149: if (clazz[i] != null) {
150: claxx[i] = reflector.forClass(clazz[i]);
151: }
152: }
153: }
154: return claxx;
155: }
156:
157: /**
158: * Creates Class[] array from the ReflectClass[]
159: * array
160: * @param claxx ReflectClass array
161: * @return Class[] array
162: */
163: static Class[] toNative(ReflectClass[] claxx) {
164: Class[] clazz = null;
165: if (claxx != null) {
166: clazz = new Class[claxx.length];
167: for (int i = 0; i < claxx.length; i++) {
168: clazz[i] = toNative(claxx[i]);
169: }
170: }
171: return clazz;
172: }
173:
174: /**
175: * Translates a ReflectClass into a native Class
176: * @param claxx ReflectClass to translate
177: * @return Class
178: */
179: public static Class toNative(ReflectClass claxx) {
180: if (claxx == null) {
181: return null;
182: }
183: if (claxx instanceof JavaReflectClass) {
184: return ((JavaReflectClass) claxx).getJavaClass();
185: }
186: ReflectClass d = claxx.getDelegate();
187: if (d == claxx) {
188: return null;
189: }
190: return toNative(d);
191: }
192:
193: }
|