org.eclipse.persistence.tools.schemaframework.PopulationManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.eclipse.persistence.core Show documentation
Show all versions of org.eclipse.persistence.core Show documentation
EclipseLink build based upon Git transaction ecdf3c32c4
/*
* Copyright (c) 1998, 2018 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0,
* or the Eclipse Distribution License v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
// Contributors:
// Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.tools.schemaframework;
import java.util.*;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
*
* Purpose: This class is used to populate example data into the database, it allows for circular references to be resolved.
*
* Responsibilities:
*
* - Allow objects to be registered.
*
- Allow objects to be looked up.
*
- Store a globally accessible default instance.
*
*/
public class PopulationManager {
/** Store the objects registered. */
protected Hashtable registeredObjects;
/** Store the default instance. */
protected static PopulationManager defaultManager;
public PopulationManager() {
registeredObjects = new Hashtable();
}
/**
* Add all of the objects of the class and all of its subclasses.
* The session is needed because there is no other way to find all subclasses.
*/
public void addAllObjectsForAbstractClass(Class objectsClass, AbstractSession session, Vector allObjects) {
ClassDescriptor descriptor = session.getDescriptor(objectsClass);
addAllObjectsForClass(objectsClass, allObjects);
for (ClassDescriptor child : descriptor.getInheritancePolicy().getChildDescriptors()) {
addAllObjectsForAbstractClass(child.getJavaClass(), session, allObjects);
}
}
/**
* Add all of the objects of the class and all of its subclasses.
* The session is needed because there is no other way to find all subclasses.
*/
public void addAllObjectsForAbstractClass(Class objectsClass, org.eclipse.persistence.sessions.Session session, Vector allObjects) {
addAllObjectsForAbstractClass(objectsClass, (AbstractSession)session, allObjects);
}
/**
* Add all of the objects of the class.
*/
public void addAllObjectsForClass(Class objectsClass, List allObjects) {
if (!getRegisteredObjects().containsKey(objectsClass)) {
return;
}
for (Object object : ((Map)getRegisteredObjects().get(objectsClass)).values()) {
allObjects.add(object);
}
}
/**
* Check if the object is registered given its name.
*/
public boolean containsObject(Class objectsClass, String objectsName) {
return ((getRegisteredObjects().containsKey(objectsClass)) && (((Hashtable)getRegisteredObjects().get(objectsClass)).containsKey(objectsName)));
}
/**
* Check if the object is registered given its name.
*/
public boolean containsObject(Object objectToCheck, String objectsName) {
return containsObject(objectToCheck.getClass(), objectsName);
}
/**
* Return all of the objects registered.
*/
public Vector getAllClasses() {
Vector allClasses = new Vector();
for (Enumeration e = getRegisteredObjects().keys(); e.hasMoreElements();) {
allClasses.addElement(e.nextElement());
}
return allClasses;
}
/**
* Return all of the objects registered.
*/
public Vector getAllObjects() {
Vector allObjects;
allObjects = new Vector();
for (Enumeration e = getAllClasses().elements(); e.hasMoreElements();) {
Class eachClass = (Class)e.nextElement();
addAllObjectsForClass(eachClass, allObjects);
}
return allObjects;
}
/**
* Return all of the objects of the class and all of its subclasses.
*/
public Vector getAllObjectsForAbstractClass(Class objectsClass) {
Vector allObjects;
allObjects = new Vector();
// hummm, how can this be done....
return allObjects;
}
/**
* Return all of the objects of the class and all of its subclasses.
* The session is needed because there is no other way to find all subclasses.
*/
public Vector getAllObjectsForAbstractClass(Class objectsClass, AbstractSession session) {
ClassDescriptor descriptor = session.getDescriptor(objectsClass);
Vector allObjects = new Vector();
addAllObjectsForClass(objectsClass, allObjects);
if (descriptor.hasInheritance()) {
for (ClassDescriptor child : descriptor.getInheritancePolicy().getChildDescriptors()) {
addAllObjectsForClass(child.getJavaClass(), allObjects);
}
}
return allObjects;
}
/**
* Return all of the objects of the class.
*/
public Vector getAllObjectsForClass(Class objectsClass) {
Vector allObjects;
allObjects = new Vector();
addAllObjectsForClass(objectsClass, allObjects);
return allObjects;
}
/**
* Lazy initialize the default instance.
*/
public static PopulationManager getDefaultManager() {
if (defaultManager == null) {
defaultManager = new PopulationManager();
}
return defaultManager;
}
/**
* Return the object registered given its name.
*/
public Object getObject(Class objectsClass, String objectsName) {
if (!(getRegisteredObjects().containsKey(objectsClass))) {
return null;
}
return ((Hashtable)getRegisteredObjects().get(objectsClass)).get(objectsName);
}
/**
* Return the registered objects.
*/
public Hashtable getRegisteredObjects() {
return registeredObjects;
}
/**
* Register the object given its name.
* The objects are represented as a hashtable of hashtables, lazy initialized on the class.
*/
public Object registerObject(Class javaClass, Object objectToRegister, String objectsName) {
if (!(getRegisteredObjects().containsKey(javaClass))) {
getRegisteredObjects().put(javaClass, new Hashtable());
}
((Hashtable)getRegisteredObjects().get(javaClass)).put(objectsName, objectToRegister);
return objectToRegister;
}
/**
* Register the object given its name.
* The objects are represented as a hashtable of hashtables, lazy initialized on the class.
*/
public Object registerObject(Object objectToRegister, String objectsName) {
if (!(getRegisteredObjects().containsKey(objectToRegister.getClass()))) {
getRegisteredObjects().put(objectToRegister.getClass(), new Hashtable());
}
((Hashtable)getRegisteredObjects().get(objectToRegister.getClass())).put(objectsName, objectToRegister);
return objectToRegister;
}
/**
* Remove the object given its class and name.
*/
public void removeObject(Class classToRemove, String objectsName) {
if (getRegisteredObjects().containsKey(classToRemove)) {
((Hashtable)getRegisteredObjects().get(classToRemove)).remove(objectsName);
}
}
/**
* Remove the object given its name.
*/
public Object removeObject(Object objectToRemove, String objectsName) {
removeObject(objectToRemove.getClass(), objectsName);
return objectToRemove;
}
/**
* Reset the default instance.
*/
public static void resetDefaultManager() {
defaultManager = null;
}
/**
* Set the default instance.
*/
public static void setDefaultManager(PopulationManager theDefaultManager) {
defaultManager = theDefaultManager;
}
/**
* Set the registered objects.
*/
public void setRegisteredObjects(Hashtable registeredObjects) {
this.registeredObjects = registeredObjects;
}
}