public Bean(String classPackage, String clazz, ClassLoaderStrategy cls, Bean topLevelBean)
throws Exception {
// Get the no-arg constructor and create the bean
try {
Class classOfBean = ObjectXml.getClassOfBean((ClassLoader) cls, classPackage + "." + clazz);
Constructor ct = null;
// check whether this class is an inner class
if (classOfBean.getEnclosingClass() != null) {
ct = classOfBean.getConstructor(new Class[] {classOfBean.getEnclosingClass()});
beanObject = ct.newInstance(new Object[] {topLevelBean.getBeanObject()});
} else {
ct = classOfBean.getConstructor((Class[]) null);
beanObject = ct.newInstance((Object[]) null);
}
// Get an array of property descriptors
beanInfo = Introspector.getBeanInfo(classOfBean);
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
// load property descriptors into hashtable
propDesc = new Properties();
for (int i = 0; i < pds.length; i++) {
propDesc.put(pds[i].getName(), pds[i]);
}
} catch (Exception e) {
System.err.println("Exception creating bean: " + e.getMessage());
e.printStackTrace();
throw e;
}
}
/** For internal use only. */
private static Object makeDerivedWrapper(Element elt, String baseTypeName) {
synchronized (DOMUtils.getDOMLock(elt)) {
QName typeName = XArchUtils.getXSIType(elt);
if (typeName == null) {
return null;
} else {
if (!DOMUtils.hasXSIType(
elt, "http://www.ics.uci.edu/pub/arch/xArch/changesets.xsd", baseTypeName)) {
try {
String packageTitle = XArchUtils.getPackageTitle(typeName.getNamespaceURI());
String packageName = XArchUtils.getPackageName(packageTitle);
String implName = XArchUtils.getImplName(packageName, typeName.getName());
Class c = Class.forName(implName);
java.lang.reflect.Constructor con = c.getConstructor(new Class[] {Element.class});
Object o = con.newInstance(new Object[] {elt});
return o;
} catch (Exception e) {
// Lots of bad things could happen, but this
// is OK, because this is best-effort anyway.
}
}
return null;
}
}
}
private Object deserialize(Node node, boolean setProperty, boolean popBean) throws Exception {
Object object = null;
currentType = null;
currentNode = node;
currentName = node.getNodeName();
boolean isNull = false;
NamedNodeMap attrs = node.getAttributes();
String arrayType = null;
for (int i = 0; i < attrs.getLength(); i++) {
String nodeName = attrs.item(i).getNodeName();
String nodeValue = attrs.item(i).getNodeValue();
if (nodeName.equals(NamespaceConstants.NSPREFIX_SCHEMA_XSI + ":" + Constants.ATTR_TYPE))
currentType = new StringBuffer(nodeValue).delete(0, nodeValue.indexOf(':') + 1).toString();
else if (nodeName.equals(
NamespaceConstants.NSPREFIX_SOAP_ENCODING + ":" + Constants.ATTR_ARRAY_TYPE))
arrayType = new StringBuffer(nodeValue).delete(0, nodeValue.indexOf(':') + 1).toString();
else if (nodeName.equals(NamespaceConstants.NSPREFIX_SCHEMA_XSI + ":null"))
isNull = nodeValue.equals("true");
}
Class cls = null;
if (currentType != null) cls = getXsdTypeClass(currentType);
// Handle array, Vector, ArrayList, LinkedList, Hashtable,
// Properties, and HashMap data types
if ((cls != null)
&& ((cls == java.lang.reflect.Array.class)
|| (cls == Vector.class)
|| (cls == ArrayList.class)
|| (cls == LinkedList.class)
|| (cls == Hashtable.class)
|| (cls == Properties.class)
|| (cls == HashMap.class)
|| (cls == SortedMap.class))) {
parentNode = currentNode;
String name = node.getNodeName();
// Handle arrays
if (cls == java.lang.reflect.Array.class) {
int a = arrayType.indexOf("[");
int b = arrayType.indexOf("]");
String s = arrayType.substring(a + 1, b);
int arrayLen = Integer.valueOf(s).intValue();
arrayType = arrayType.substring(0, a);
// check if the array element is a standard Java class
Class arrayClass = getXsdTypeClass(arrayType);
// otherwise try to get the class of the bean
if (arrayClass == null)
arrayClass = getClassOfBean((ClassLoader) classLoaderStrategy, arrayType);
object = java.lang.reflect.Array.newInstance(arrayClass, arrayLen);
} else {
// Construct the list or map type
Constructor ct = cls.getConstructor((Class[]) null);
object = ct.newInstance((Object[]) null);
}
// deserialize the elements of the array, list, or map
NodeList childNodes = node.getChildNodes();
int arrayIndex = -1;
Node childNode = null;
Object nodeObj = null;
for (int i = 0; i < childNodes.getLength(); i++) {
childNode = childNodes.item(i);
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
if ((cls == java.lang.reflect.Array.class)
|| (cls == Vector.class)
|| (cls == ArrayList.class)
|| (cls == LinkedList.class)) {
nodeObj = deserialize(childNode, false, true);
if (nodeObj != null) {
if (cls == java.lang.reflect.Array.class)
java.lang.reflect.Array.set(object, ++arrayIndex, nodeObj);
else ((List) object).add(nodeObj);
}
} else if ((cls == Hashtable.class)
|| (cls == Properties.class)
|| (cls == HashMap.class)
|| (cls == SortedMap.class)) {
if (childNode.getLocalName().equals("item")) {
NodeList htNodes = childNode.getChildNodes();
if (htNodes.getLength() == 2) {
Object hashKey = deserialize(htNodes.item(0), false, false);
Object hashValue = deserialize(htNodes.item(1), false, true);
((Map) object).put(hashKey, hashValue);
}
}
}
}
}
setBeanProperty(name, object);
// Handle everything else (primitives & POJOs)
} else {
// recurse on each of the child nodes
NodeList childNodes = node.getChildNodes();
if ((childNodes != null) && (childNodes.getLength() > 0)) {
for (int i = 0; i < childNodes.getLength(); i++) {
Node childNode = childNodes.item(i);
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
if (currentType != null)
createObject(
node,
currentName,
currentPackage,
currentType,
childNode.getNodeValue(),
setProperty);
parentNode = node;
object = deserialize(childNode, true, true);
} else if ((childNode.getNodeType() == Node.TEXT_NODE) && (currentType != null)) {
object =
createObject(
node,
currentName,
currentPackage,
currentType,
childNode.getNodeValue(),
setProperty);
}
currentType = null;
}
} else {
if (!isNull)
object = createObject(node, currentName, currentPackage, currentType, null, setProperty);
}
if (node.getParentNode() != parentNode) {
parentNode = node.getParentNode();
if (popBean) {
Object bean = popBeanOffStack();
if (bean != null) object = bean;
}
}
}
return object;
}
/**
* Unmarshall a Chromosome instance from a given XML Element representation.
*
* @param a_activeConfiguration current Configuration object
* @param a_xmlElement the XML Element representation of the Chromosome
* @return a new Chromosome instance setup with the data from the XML Element representation
* @throws ImproperXMLException if the given Element is improperly structured or missing data
* @throws UnsupportedRepresentationException if the actively configured Gene implementation does
* not support the string representation of the alleles used in the given XML document
* @throws GeneCreationException if there is a problem creating or populating a Gene instance
* @author Neil Rotstan
* @since 1.0
*/
public static Gene[] getGenesFromElement(
Configuration a_activeConfiguration, Element a_xmlElement)
throws ImproperXMLException, UnsupportedRepresentationException, GeneCreationException {
// Do some sanity checking. Make sure the XML Element isn't null and
// that it in fact represents a set of genes.
// -----------------------------------------------------------------
if (a_xmlElement == null || !(a_xmlElement.getTagName().equals(GENES_TAG))) {
throw new ImproperXMLException(
"Unable to build Chromosome instance from XML Element: "
+ "given Element is not a 'genes' element.");
}
List genes = Collections.synchronizedList(new ArrayList());
// Extract the nested gene elements.
// ---------------------------------
NodeList geneElements = a_xmlElement.getElementsByTagName(GENE_TAG);
if (geneElements == null) {
throw new ImproperXMLException(
"Unable to build Gene instances from XML Element: "
+ "'"
+ GENE_TAG
+ "'"
+ " sub-elements not found.");
}
// For each gene, get the class attribute so we know what class
// to instantiate to represent the gene instance, and then find
// the child text node, which is where the string representation
// of the allele is located, and extract the representation.
// -------------------------------------------------------------
int numberOfGeneNodes = geneElements.getLength();
for (int i = 0; i < numberOfGeneNodes; i++) {
Element thisGeneElement = (Element) geneElements.item(i);
thisGeneElement.normalize();
// Fetch the class attribute and create an instance of that
// class to represent the current gene.
// --------------------------------------------------------
String geneClassName = thisGeneElement.getAttribute(CLASS_ATTRIBUTE);
Gene thisGeneObject;
Class geneClass = null;
try {
geneClass = Class.forName(geneClassName);
try {
Constructor constr = geneClass.getConstructor(new Class[] {Configuration.class});
thisGeneObject = (Gene) constr.newInstance(new Object[] {a_activeConfiguration});
} catch (NoSuchMethodException nsme) {
// Try it by calling method newGeneInternal.
// -----------------------------------------
Constructor constr = geneClass.getConstructor(new Class[] {});
thisGeneObject = (Gene) constr.newInstance(new Object[] {});
thisGeneObject =
(Gene)
PrivateAccessor.invoke(
thisGeneObject, "newGeneInternal", new Class[] {}, new Object[] {});
}
} catch (Throwable e) {
throw new GeneCreationException(geneClass, e);
}
// Find the text node and fetch the string representation of
// the allele.
// ---------------------------------------------------------
NodeList children = thisGeneElement.getChildNodes();
int childrenSize = children.getLength();
String alleleRepresentation = null;
for (int j = 0; j < childrenSize; j++) {
Element alleleElem = (Element) children.item(j);
if (alleleElem.getTagName().equals(ALLELE_TAG)) {
alleleRepresentation = alleleElem.getAttribute("value");
}
if (children.item(j).getNodeType() == Node.TEXT_NODE) {
// We found the text node. Extract the representation.
// ---------------------------------------------------
alleleRepresentation = children.item(j).getNodeValue();
break;
}
}
// Sanity check: Make sure the representation isn't null.
// ------------------------------------------------------
if (alleleRepresentation == null) {
throw new ImproperXMLException(
"Unable to build Gene instance from XML Element: "
+ "value (allele) is missing representation.");
}
// Now set the value of the gene to that reflect the
// string representation.
// -------------------------------------------------
try {
thisGeneObject.setValueFromPersistentRepresentation(alleleRepresentation);
} catch (UnsupportedOperationException e) {
throw new GeneCreationException(
"Unable to build Gene because it does not support the "
+ "setValueFromPersistentRepresentation() method.");
}
// Finally, add the current gene object to the list of genes.
// ----------------------------------------------------------
genes.add(thisGeneObject);
}
return (Gene[]) genes.toArray(new Gene[genes.size()]);
}