PopulationManager


1   /*
2    * The contents of this file are subject to the terms 
3    * of the Common Development and Distribution License 
4    * (the "License").  You may not use this file except 
5    * in compliance with the License.
6    * 
7    * You can obtain a copy of the license at 
8    * glassfish/bootstrap/legal/CDDLv1.0.txt or 
9    * https://glassfish.dev.java.net/public/CDDLv1.0.html. 
10   * See the License for the specific language governing 
11   * permissions and limitations under the License.
12   * 
13   * When distributing Covered Code, include this CDDL 
14   * HEADER in each file and include the License file at 
15   * glassfish/bootstrap/legal/CDDLv1.0.txt.  If applicable, 
16   * add the following below this CDDL HEADER, with the 
17   * fields enclosed by brackets "[]" replaced with your 
18   * own identifying information: Portions Copyright [yyyy] 
19   * [name of copyright owner]
20   */
21  // Copyright (c) 1998, 2005, Oracle. All rights reserved.  
22  package oracle.toplink.essentials.tools.schemaframework;
23  
24  import java.util.*;
25  import oracle.toplink.essentials.internal.sessions.AbstractSession;
26  import oracle.toplink.essentials.descriptors.ClassDescriptor;
27  
28  /**
29   * <p>
30   * <b>Purpose</b>: This class is used to populate example data into the database, it allows for cirrcular references to be resolved.
31   * <p>
32   * <b>Responsibilities</b>:
33   * <ul>
34   * <li> Allow objects to be registered.
35   * <li> Allow objects to be looked up.
36   * <li> Store a globally accessable default instance.
37   */
38  public class PopulationManager {
39  
40      /** Store the objects registered. */
41      protected Hashtable registeredObjects;
42  
43      /** Store the default instance. */
44      protected static PopulationManager defaultManager;
45  
46      public PopulationManager() {
47          registeredObjects = new Hashtable();
48      }
49  
50      /**
51       * Add all of the objects of the class and all of its subclasses.
52       * The session is needed because there is no other way to find all subclasses.
53       */
54      public void addAllObjectsForAbstractClass(Class   objectsClass, AbstractSession session, Vector allObjects) {
55          ClassDescriptor descriptor = session.getDescriptor(objectsClass);
56          addAllObjectsForClass(objectsClass, allObjects);
57          for (Enumeration enumeration = descriptor.getInheritancePolicy().getChildDescriptors().elements();
58                   enumeration.hasMoreElements();) {
59              addAllObjectsForAbstractClass(((ClassDescriptor)enumeration.nextElement()).getJavaClass(), session, allObjects);
60          }
61      }
62  
63      /**
64       * Add all of the objects of the class and all of its subclasses.
65       * The session is needed because there is no other way to find all subclasses.
66       */
67      public void addAllObjectsForAbstractClass(Class   objectsClass, oracle.toplink.essentials.sessions.Session session, Vector allObjects) {
68          addAllObjectsForAbstractClass(objectsClass, (AbstractSession)session, allObjects);
69      }
70  
71      /**
72       * Add all of the objects of the class.
73       */
74      public void addAllObjectsForClass(Class   objectsClass, Vector allObjects) {
75          if (!getRegisteredObjects().containsKey(objectsClass)) {
76              return;
77          }
78  
79          for (Enumeration enumeration = ((Hashtable)getRegisteredObjects().get(objectsClass)).elements();
80                   enumeration.hasMoreElements();) {
81              allObjects.addElement(enumeration.nextElement());
82          }
83      }
84  
85      /**
86       * Check if the object is registred given its name.
87       */
88      public boolean containsObject(Class   objectsClass, String   objectsName) {
89          return ((getRegisteredObjects().containsKey(objectsClass)) && (((Hashtable)getRegisteredObjects().get(objectsClass)).containsKey(objectsName)));
90      }
91  
92      /**
93       * Check if the object is registred given its name.
94       */
95      public boolean containsObject(Object   objectToCheck, String   objectsName) {
96          return containsObject(objectToCheck.getClass(), objectsName);
97      }
98  
99      /**
100      * Return all of the objects registered.
101      */
102     public Vector getAllClasses() {
103         Vector allClasses = new Vector();
104 
105         for (Enumeration e = getRegisteredObjects().keys(); e.hasMoreElements();) {
106             allClasses.addElement(e.nextElement());
107         }
108 
109         return allClasses;
110     }
111 
112     /**
113      * Return all of the objects registered.
114      */
115     public Vector getAllObjects() {
116         Vector allObjects;
117 
118         allObjects = new Vector();
119         for (Enumeration e = getAllClasses().elements(); e.hasMoreElements();) {
120             Class   eachClass = (Class  )e.nextElement();
121             addAllObjectsForClass(eachClass, allObjects);
122         }
123 
124         return allObjects;
125     }
126 
127     /**
128      * Return all of the objects of the class and all of its subclasses.
129      */
130     public Vector getAllObjectsForAbstractClass(Class   objectsClass) {
131         Vector allObjects;
132 
133         allObjects = new Vector();
134         // hummm, how can this be done....
135         return allObjects;
136     }
137 
138     /**
139      * Return all of the objects of the class and all of its subclasses.
140      * The session is needed because there is no other way to find all subclasses.
141      */
142     public Vector getAllObjectsForAbstractClass(Class   objectsClass, AbstractSession session) {
143         ClassDescriptor descriptor = session.getDescriptor(objectsClass);
144         Vector allObjects = new Vector();
145         addAllObjectsForClass(objectsClass, allObjects);
146         if (descriptor.hasInheritance()) {
147             for (Enumeration enumeration = descriptor.getInheritancePolicy().getChildDescriptors().elements();
148                      enumeration.hasMoreElements();) {
149                 addAllObjectsForClass(((ClassDescriptor)enumeration.nextElement()).getJavaClass(), allObjects);
150             }
151         }
152 
153         return allObjects;
154     }
155 
156     /**
157      * Return all of the objects of the class.
158      */
159     public Vector getAllObjectsForClass(Class   objectsClass) {
160         Vector allObjects;
161 
162         allObjects = new Vector();
163         addAllObjectsForClass(objectsClass, allObjects);
164 
165         return allObjects;
166     }
167 
168     /**
169      * Lazy initialize the default instance.
170      */
171     public static PopulationManager getDefaultManager() {
172         if (defaultManager == null) {
173             defaultManager = new PopulationManager();
174         }
175         return defaultManager;
176     }
177 
178     /**
179      * Return the object registred given its name.
180      */
181     public Object   getObject(Class   objectsClass, String   objectsName) {
182         if (!(getRegisteredObjects().containsKey(objectsClass))) {
183             return null;
184         }
185 
186         return ((Hashtable)getRegisteredObjects().get(objectsClass)).get(objectsName);
187     }
188 
189     /**
190      * Return the registered objects.
191      */
192     public Hashtable getRegisteredObjects() {
193         return registeredObjects;
194     }
195 
196     /**
197      * Register the object given its name.
198      * The objects are represented as a hashtable of hashtables, lazy initialized on the class.
199      */
200     public Object   registerObject(Class   javaClass, Object   objectToRegister, String   objectsName) {
201         if (!(getRegisteredObjects().containsKey(javaClass))) {
202             getRegisteredObjects().put(javaClass, new Hashtable());
203         }
204         ((Hashtable)getRegisteredObjects().get(javaClass)).put(objectsName, objectToRegister);
205 
206         return objectToRegister;
207     }
208 
209     /**
210      * Register the object given its name.
211      * The objects are represented as a hashtable of hashtables, lazy initialized on the class.
212      */
213     public Object   registerObject(Object   objectToRegister, String   objectsName) {
214         if (!(getRegisteredObjects().containsKey(objectToRegister.getClass()))) {
215             getRegisteredObjects().put(objectToRegister.getClass(), new Hashtable());
216         }
217         ((Hashtable)getRegisteredObjects().get(objectToRegister.getClass())).put(objectsName, objectToRegister);
218 
219         return objectToRegister;
220     }
221 
222     /**
223      * Remove the object given its class and name.
224      */
225     public void removeObject(Class   classToRemove, String   objectsName) {
226         if (getRegisteredObjects().containsKey(classToRemove)) {
227             ((Hashtable)getRegisteredObjects().get(classToRemove)).remove(objectsName);
228         }
229     }
230 
231     /**
232      * Remove the object given its name.
233      */
234     public Object   removeObject(Object   objectToRemove, String   objectsName) {
235         removeObject(objectToRemove.getClass(), objectsName);
236 
237         return objectToRemove;
238     }
239 
240     /**
241      * Reset the default instance.
242      */
243     public static void resetDefaultManager() {
244         defaultManager = null;
245     }
246 
247     /**
248      * Set the default instance.
249      */
250     public static void setDefaultManager(PopulationManager theDefaultManager) {
251         defaultManager = theDefaultManager;
252     }
253 
254     /**
255      * Set the registered objects.
256      */
257     public void setRegisteredObjects(Hashtable registeredObjects) {
258         this.registeredObjects = registeredObjects;
259     }
260 }
261
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags