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.util.Map;
21 import java.util.Set;
22 import java.util.HashMap;
23 import java.util.HashSet;
24 import java.io.InputStream;
25
26 import org.apache.jdo.model.ModelException;
27 import org.apache.jdo.model.java.JavaModel;
28 import org.apache.jdo.model.java.JavaType;
29 import org.apache.jdo.model.jdo.JDOModel;
30
31
32 /***
33 * Abstract super class for JavaModel implementations.
34 * It implements the jdoModel property and the parent/child relationship
35 * between javaModels. It also provides a map of types managed by this
36 * JavaModel (see {@link #types}). The AbstractJavaModel constructor
37 * automatically adds all the predefined types to this map.
38 * <p>
39 * A non-abstract subclass must implement methods
40 * {@link #getJavaType(String name)} and
41 * {@link #getInputStreamForResource(String resourceName)}.
42 *
43 * @author Michael Bouschen
44 * @since JDO 1.0.1
45 */
46 abstract public class AbstractJavaModel
47 implements JavaModel
48 {
49 /*** Map of known JavaTypes. Key is the type name as a string. */
50 protected Map types;
51
52 /*** The parent JavaModel. */
53 protected JavaModel parent;
54
55 /*** The child JavaModels. */
56 protected Set children = new HashSet();
57
58 /*** The corresponding JDOModel instance. */
59 protected JDOModel jdoModel;
60
61 /***
62 * Constructor. It adds all predefined types to the cache of types
63 * known by this model instance.
64 * @see PredefinedType
65 */
66 protected AbstractJavaModel()
67 {
68 types = new HashMap(PredefinedType.getPredefinedTypes());
69 }
70
71 /***
72 * The method returns the JavaType instance for the specified type
73 * name. A type name is unique within one JavaModel instance. The
74 * method returns <code>null</code> if this model instance does not
75 * know a type with the specified name.
76 * @return a JavaType instance for the specified name or
77 * <code>null</code> if not present in this model instance.
78 */
79 abstract public JavaType getJavaType(String name);
80
81 /***
82 * The method returns the JavaType instance for the type name of the
83 * specified class object. This is a convenience method for
84 * <code>getJavaType(clazz.getName())</code>. The major difference
85 * between this method and getJavaType taking a type name is that this
86 * method is supposed to return a non-<code>null<code> value. The
87 * specified class object describes an existing type.
88 * @param clazz the Class instance representing the type
89 * @return a JavaType instance for the name of the specified class
90 * object.
91 */
92 public JavaType getJavaType(Class clazz)
93 {
94 return (clazz == null) ? null : getJavaType(clazz.getName());
95 }
96
97 /***
98 * Finds a resource with a given name. A resource is some data that can
99 * be accessed by class code in a way that is independent of the
100 * location of the code. The name of a resource is a "/"-separated path
101 * name that identifies the resource. The method method opens the
102 * resource for reading and returns an InputStream. It returns
103 * <code>null</code> if no resource with this name is found or if the
104 * caller doesn't have adequate privileges to get the resource.
105 * @param resourceName the resource name
106 * @return an input stream for reading the resource, or <code>null</code>
107 * if the resource could not be found or if the caller doesn't have
108 * adequate privileges to get the resource.
109 */
110 abstract public InputStream getInputStreamForResource(String resourceName);
111
112 /***
113 * Returns the parent JavaModel instance of this JavaModel.
114 * @return the parent JavaModel
115 */
116 public JavaModel getParent()
117 {
118 return parent;
119 }
120
121 /***
122 * Set the parent JavaModel for this JavaModel. The method
123 * automatically adds this JavaModel to the collection of children
124 * of the specified parent JavaModel.
125 * @param parent the parent JavaModel
126 * @exception ModelException if impossible
127 */
128 public void setParent(JavaModel parent)
129 throws ModelException
130 {
131 if (this.parent == parent) {
132
133 return;
134 }
135 if (this.parent != null) {
136
137 ((AbstractJavaModel)this.parent).children.remove(this);
138
139 ((AbstractJavaModel)parent).children.add(this);
140 }
141 this.parent = parent;
142 }
143
144 /***
145 * Returns a collection of child JavaModel instances in the form
146 * of an array. All instances from the returned array have this
147 * JavaModel instance as parent.
148 * @return the child JavaModel instances
149 */
150 public JavaModel[] getChildren()
151 {
152 return (JavaModel[])children.toArray(new JavaModel[children.size()]);
153 }
154
155 /***
156 * Returns the corresponding JDOModel instance.
157 * @return the corresponding JDOModel.
158 */
159 public JDOModel getJDOModel()
160 {
161 return jdoModel;
162 }
163
164 /***
165 * Sets the corresponding JDOModel instance.
166 * @param jdoModel the JDOModel instance
167 * @exception ModelException if impossible
168 */
169 public void setJDOModel(JDOModel jdoModel)
170 throws ModelException
171 {
172 this.jdoModel = jdoModel;
173 }
174
175 }
176