1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.jdo.impl.model.java;
19
20 import java.lang.reflect.Field;
21
22 import org.apache.jdo.model.ModelFatalException;
23 import org.apache.jdo.model.java.JavaField;
24 import org.apache.jdo.model.java.JavaProperty;
25 import org.apache.jdo.model.java.JavaType;
26 import org.apache.jdo.util.I18NHelper;
27
28
29
30 /***
31 * This class provides a basic JavaType implementation using a reflection
32 * Class instance.
33 * <p>
34 * Note, BaseReflectionJavaType must not be used for array types, since it inherits
35 * the default implemention of methods isArray and getArrayComponentType
36 * from its superclass AbstractJavaType.
37 *
38 * @author Michael Bouschen
39 * @since JDO 1.1
40 */
41 public class BaseReflectionJavaType
42 extends AbstractJavaType
43 {
44 /*** The java.lang.Class instance for this BaseReflectionJavaType. */
45 protected Class clazz;
46
47 /*** The superclass JavaType. */
48 protected JavaType superclass;
49
50 /*** I18N support */
51 private static I18NHelper msg =
52 I18NHelper.getInstance(BaseReflectionJavaType.class);
53
54 /***
55 * Constructor. The specified java.lang.Class instance must not be
56 * <code>null</code>. The
57 * @param clazz the Class instance representing the type
58 * @param superclass JavaType instance representing the superclass.
59 */
60 public BaseReflectionJavaType(Class clazz, JavaType superclass)
61 {
62 if (clazz == null)
63 throw new ModelFatalException(msg.msg(
64 "ERR_InvalidNullClassInstance", "BaseReflectionJavaType.<init>"));
65 this.clazz = clazz;
66 this.superclass = superclass;
67 }
68
69
70
71 /***
72 * Returns the environment specific instance wrapped by this JavaModel
73 * element. This implementation returns the
74 * <code>java.lang.Class</code> instance for this JavaType.
75 * @return the environment specific instance wrapped by this JavaModel
76 * element.
77 */
78 public Object getUnderlyingObject()
79 {
80 return getJavaClass();
81 }
82
83
84
85 /***
86 * Determines if this JavaType object represents an interface type.
87 * @return <code>true</code> if this object represents an interface type;
88 * <code>false</code> otherwise.
89 */
90 public boolean isInterface()
91 {
92 return clazz.isInterface();
93 }
94
95 /***
96 * Returns true if this JavaType is compatible with the specified
97 * JavaType.
98 * @param javaType the type this JavaType is checked with.
99 * @return <code>true</code> if this is compatible with the specified
100 * type; <code>false</code> otherwise.
101 */
102 public boolean isCompatibleWith(JavaType javaType)
103 {
104 if (javaType == null)
105 return false;
106
107 if (javaType instanceof BaseReflectionJavaType) {
108 BaseReflectionJavaType otherType = (BaseReflectionJavaType)javaType;
109 return otherType.getJavaClass().isAssignableFrom(clazz);
110 }
111
112 return false;
113 }
114
115 /***
116 * Returns the name of the type. If this type represents a class or
117 * interface, the name is fully qualified.
118 * @return type name
119 */
120 public String getName()
121 {
122 return clazz.getName();
123 }
124
125 /***
126 * Returns the Java language modifiers for the field represented by
127 * this JavaType, as an integer. The java.lang.reflect.Modifier class
128 * should be used to decode the modifiers.
129 * @return the Java language modifiers for this JavaType
130 */
131 public int getModifiers()
132 {
133 return clazz.getModifiers();
134 }
135
136 /***
137 * Returns the JavaType representing the superclass of the entity
138 * represented by this JavaType. If this JavaType represents either the
139 * Object class, an interface, a primitive type, or <code>void</code>,
140 * then <code>null</code> is returned. If this object represents an
141 * array class then the JavaType instance representing the Object class
142 * is returned.
143 * @return the superclass of the class represented by this JavaType.
144 */
145 public JavaType getSuperclass()
146 {
147 return superclass;
148 }
149
150 /***
151 * Returns a JavaField instance that reflects the field with the
152 * specified name of the class or interface represented by this
153 * JavaType instance. The method returns <code>null</code>, if the
154 * class or interface (or one of its superclasses) does not have a
155 * field with that name.
156 * @param fieldName the name of the field
157 * @return the JavaField instance for the specified field in this class
158 * or <code>null</code> if there is no such field.
159 */
160 public JavaField getJavaField(String fieldName)
161 {
162 Field field =
163 BaseReflectionJavaField.getDeclaredFieldPrivileged(clazz, fieldName);
164 if (field != null) {
165 return new BaseReflectionJavaField(field, this);
166 }
167
168
169 JavaType superclass = getSuperclass();
170 if ((superclass != null) && (superclass != PredefinedType.objectType)) {
171 return superclass.getJavaField(fieldName);
172 }
173
174 return null;
175 }
176
177 /*** */
178 public JavaField[] getDeclaredJavaFields()
179 {
180 throw new UnsupportedOperationException();
181 }
182
183 /*** */
184 public JavaProperty getJavaProperty(String name)
185 {
186 throw new UnsupportedOperationException();
187 }
188
189 /*** */
190 public JavaProperty[] getDeclaredJavaProperties()
191 {
192 throw new UnsupportedOperationException();
193 }
194
195
196
197 /***
198 * Returns the java.lang.Class instance wrapped by this JavaType.
199 * @return the Class instance for this JavaType.
200 */
201 public Class getJavaClass()
202 {
203 return clazz;
204 }
205
206 }