/**
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* 1. Redistributions of source code must retain copyright
* statements and notices. Redistributions must also contain a
* copy of this document.
*
* 2. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. The name "Exolab" must not be used to endorse or promote
* products derived from this Software without prior written
* permission of Intalio, Inc. For written permission,
* please contact info@exolab.org.
*
* 4. Products derived from this Software may not be called "Exolab"
* nor may "Exolab" appear in their names without prior written
* permission of Intalio, Inc. Exolab is a registered
* trademark of Intalio, Inc.
*
* 5. Due credit should be given to the Exolab Project
* (http://www.exolab.org/).
*
* THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 1999-2003 (C) Intalio, Inc. All Rights Reserved.
*
* $Id$
*/
package org.exolab.castor.tools;
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import org.castor.xml.BackwardCompatibilityContext;
import org.castor.xml.InternalContext;
import org.exolab.castor.mapping.FieldDescriptor;
import org.exolab.castor.mapping.MappingException;
import org.exolab.castor.mapping.loader.CollectionHandlers;
import org.exolab.castor.mapping.loader.Types;
import org.exolab.castor.mapping.xml.BindXml;
import org.exolab.castor.mapping.xml.ClassChoice;
import org.exolab.castor.mapping.xml.ClassMapping;
import org.exolab.castor.mapping.xml.FieldMapping;
import org.exolab.castor.mapping.xml.MapTo;
import org.exolab.castor.mapping.xml.MappingRoot;
import org.exolab.castor.mapping.xml.types.BindXmlNodeType;
import org.exolab.castor.mapping.xml.types.FieldMappingCollectionType;
import org.exolab.castor.util.CommandLineOptions;
import org.exolab.castor.util.dialog.ConsoleDialog;
import org.exolab.castor.xml.Marshaller;
import org.exolab.castor.xml.XMLClassDescriptor;
import org.exolab.castor.xml.XMLContext;
import org.exolab.castor.xml.XMLFieldDescriptor;
/**
* A tool which uses the introspector to automatically
* create mappings for a given set of classes.
*
* @author <a href="arkin@intalio.com">Assaf Arkin</a>
* @author <a href="keith AT kvisco DOT com">Keith Visco</a>
* @version $Revision$ $Date: 2006-01-30 14:37:08 -0700 (Mon, 30 Jan 2006) $
*/
public class MappingTool {
/** Used for checking field names to see if they begin with an underscore '_'. */
private static final String UNDERSCORE = "_";
/** Hashtable of already generated mappings. */
private Hashtable _mappings;
/**
* The internal MappingLoader to use for checking whether or not we can find
* the proper accessor methods.
*/
private MappingToolMappingLoader _mappingLoader;
/**
* Boolean to indicate that we should always perform introspection for each
* class even if a ClassDescriptor may exist.
*/
private boolean _forceIntrospection = false;
/**
* The XMLContext (mother of all dwelling).
*/
private InternalContext _internalContext;
/**
* Constructor, builds up the relations.
*/
public MappingTool() {
super();
} // --MappingTool
/**
* Command line method.
*
* @param args
* the command line parameters
*/
public static void main(final String[] args) {
CommandLineOptions allOptions = new CommandLineOptions();
// -- Input classname flag
allOptions.addFlag("i", "classname", "Sets the input class");
// -- Output filename flag
String desc = "Sets the output mapping filename";
allOptions.addFlag("o", "filename", desc, true);
// -- Force flag
desc = "Force overwriting of files.";
allOptions.addFlag("f", "", desc, true);
// -- Help flag
desc = "Displays this help screen.";
allOptions.addFlag("h", "", desc, true);
// -- Process the specified command line options
Properties options = allOptions.getOptions(args);
// -- check for help option
if (options.getProperty("h") != null) {
PrintWriter pw = new PrintWriter(System.out, true);
allOptions.printHelp(pw);
pw.flush();
return;
}
String classname = options.getProperty("i");
String mappingName = options.getProperty("o");
boolean force = (options.getProperty("f") != null);
if (classname == null) {
PrintWriter pw = new PrintWriter(System.out, true);
allOptions.printUsage(pw);
pw.flush();
return;
}
MappingTool tool;
try {
XMLContext xmlContext = new XMLContext();
tool = xmlContext.createMappingTool();
tool.addClass(classname);
Writer writer = null;
if ((mappingName == null) || (mappingName.length() == 0)) {
writer = new PrintWriter(System.out, true);
} else {
File file = new File(mappingName);
if (file.exists() && (!force)) {
ConsoleDialog dialog = new ConsoleDialog();
String message = "The file already exists. Do you wish " + "to overwrite '"
+ mappingName + "'?";
if (!dialog.confirm(message)) {
return;
}
}
writer = new FileWriter(file);
}
tool.write(writer);
} catch (Exception except) {
System.out.println(except);
except.printStackTrace();
}
} // -- main
/**
* Adds the Class, specified by the given name, to the mapping file.
*
* @param name
* the name of the Class to add
* @throws MappingException
* in case that the name is null or the Class can not be loaded
*/
public void addClass(final String name) throws MappingException {
addClass(name, true);
} // -- addClass
/**
* Adds the Class, specified by the given name, to the mapping file.
*
* @param name
* the name of the Class to add
* @param deep
* a flag to indicate that recursive processing should take place
* and all classes used by the given class should also be added
* to the mapping file. This flag is true by default.
* @throws MappingException
* in case that the name is null or the Class can not be loaded
*/
public void addClass(final String name, final boolean deep) throws MappingException {
if (name == null) {
throw new MappingException("Cannot introspect a null class.");
}
try {
addClass(Class.forName(name), deep);
} catch (ClassNotFoundException except) {
throw new MappingException(except);
}
} // -- addClass
/**
* Adds the given Class to the mapping file.
*
* @param cls
* the Class to add
* @throws MappingException
* in case that the name is null or the Class can not be loaded
*/
public void addClass(final Class cls) throws MappingException {
addClass(cls, true);
} // -- addClass
/**
* Adds the given Class to the mapping file. If the deep flag is true, all
* mappings for Classes used by the given Class will also be added to the
* mapping file.
*
* @param cls
* the Class to add
* @param deep
* a flag to indicate that recursive processing should take place
* and all classes used by the given class should also be added
* to the mapping file. This flag is true by default.
* @throws MappingException
* in case that the name is null or the Class can not be loaded
*/
public void addClass(final Class cls, final boolean deep) throws MappingException {
if (cls == null) {
throw new MappingException("Cannot introspect a null class.");
}
if (_mappings.get(cls) != null) {
return;
}
if (cls.isArray()) {
Class cType = cls.getComponentType();
if (_mappings.get(cType) != null) {
return;
}
if (Types.isSimpleType(cType)) {
return;
}
// -- handle component type
addClass(cType);
}
if (_forceIntrospection && (!Types.isConstructable(cls))) {
throw new MappingException("mapping.classNotConstructable", cls.getName());
}
XMLClassDescriptor xmlClass;
FieldDescriptor[] fields;
ClassMapping classMap;
FieldMapping fieldMap;
boolean introspected = false;
try {
if (_forceIntrospection) {
xmlClass = _internalContext.getIntrospector().generateClassDescriptor(cls);
introspected = true;
} else {
xmlClass = (XMLClassDescriptor) _internalContext.getXMLClassDescriptorResolver().resolve(cls);
introspected = _internalContext.getIntrospector().introspected(xmlClass);
}
} catch (Exception except) {
throw new MappingException(except);
}
classMap = new ClassMapping();
classMap.setName(cls.getName());
classMap.setDescription("Default mapping for class " + cls.getName());
// -- prevent default access from showing up in the mapping
classMap.setAccess(null);
// -- map-to
MapTo mapTo = new MapTo();
mapTo.setXml(xmlClass.getXMLName());
mapTo.setNsUri(xmlClass.getNameSpaceURI());
mapTo.setNsPrefix(xmlClass.getNameSpacePrefix());
classMap.setMapTo(mapTo);
// -- add mapping to hashtable before processing
// -- fields so we can do recursive processing
_mappings.put(cls, classMap);
fields = xmlClass.getFields();
for (int i = 0; i < fields.length; ++i) {
FieldDescriptor fdesc = fields[i];
String fieldName = fdesc.getFieldName();
boolean isContainer = false;
// -- check for collection wrapper
if (introspected && fieldName.startsWith("##container")) {
fdesc = fdesc.getClassDescriptor().getFields()[0];
fieldName = fdesc.getFieldName();
isContainer = true;
}
Class fieldType = fdesc.getFieldType();
// -- check to make sure we can find the accessors...
// -- if we used introspection we don't need to
// -- enter this block...only when descriptors
// -- were generated using the source code generator
// -- or by hand.
if ((!introspected) && fieldName.startsWith(UNDERSCORE)) {
// -- check to see if we need to remove underscore
if (!_mappingLoader.canFindAccessors(cls, fieldName, fieldType)) {
fieldName = fieldName.substring(1);
}
// -- check to see if we need to remove "List" prefix
// -- used by generated source code
if (!_mappingLoader.canFindAccessors(cls, fieldName, fieldType)) {
if (fieldName.endsWith("List")) {
int len = fieldName.length() - 4;
String tmpName = fieldName.substring(0, len);
if (_mappingLoader.canFindAccessors(cls, tmpName, fieldType)) {
fieldName = tmpName;
}
}
}
}
fieldMap = new FieldMapping();
fieldMap.setName(fieldName);
// -- unwrap arrays of objects
boolean isArray = fieldType.isArray();
while (fieldType.isArray()) {
fieldType = fieldType.getComponentType();
}
// -- To prevent outputing of optional fields...check
// -- for value first before setting
if (fdesc.isRequired()) {
fieldMap.setRequired(true);
}
if (fdesc.isTransient()) {
fieldMap.setTransient(true);
}
if (fdesc.isMultivalued()) {
// -- special case for collections
if (isContainer) {
// -- backwards than what you'd expect, but
// -- if the collection had a "container" wrapper
// -- then we specify container="false" in the
// -- mapping file.
fieldMap.setContainer(false);
}
// -- try to guess collection type
if (isArray) {
fieldMap.setCollection(FieldMappingCollectionType.ARRAY);
} else {
// -- if the fieldType is the collection, then set
// appropriate
// -- collection type
String colName = CollectionHandlers.getCollectionName(fieldType);
if (colName != null) {
fieldMap.setCollection(FieldMappingCollectionType.valueOf(colName));
fieldType = Object.class;
} else if (_mappingLoader.returnsArray(cls, fieldName, fieldType)) {
// -- help maintain compatibility with generated
// descriptors
fieldMap.setCollection(FieldMappingCollectionType.ARRAY);
} else {
fieldMap.setCollection(FieldMappingCollectionType.ENUMERATE);
}
}
}
// -- fieldType
fieldMap.setType(fieldType.getName());
// -- handle XML Specific information
fieldMap.setBindXml(new BindXml());
fieldMap.getBindXml().setName(((XMLFieldDescriptor) fdesc).getXMLName());
fieldMap.getBindXml().setNode(
BindXmlNodeType.valueOf(((XMLFieldDescriptor) fields[i]).getNodeType()
.toString()));
if (classMap.getClassChoice() == null) {
classMap.setClassChoice(new ClassChoice());
}
classMap.getClassChoice().addFieldMapping(fieldMap);
if (deep) {
if (_mappings.get(fieldType) != null) {
continue;
}
if (Types.isSimpleType(fieldType)) {
continue;
}
// -- recursive add needed classes
addClass(fieldType);
}
}
} // -- addClass
/**
* Enables or disables the forcing of introspection when a ClassDescriptor
* already exists. This is false by default.
*
* @param force
* when true will cause the MappingTool to always use
* introspection regardless of whether or not a ClassDescriptor
* exists for a given Class.
*/
public void setForceIntrospection(final boolean force) {
_forceIntrospection = force;
} // -- setForceInstrospection
/**
* Serializes the mapping to the given writer.
*
* @param writer
* the Writer to serialize the mapping to
* @throws MappingException if writing the mapping information fails
*/
public void write(final Writer writer) throws MappingException {
Marshaller marshal;
MappingRoot mapping;
Enumeration enumeration;
try {
mapping = new MappingRoot();
mapping.setDescription("Castor generated mapping file");
enumeration = _mappings.elements();
while (enumeration.hasMoreElements()) {
mapping.addClassMapping((ClassMapping) enumeration.nextElement());
}
marshal = new Marshaller(writer);
marshal.setNamespaceMapping(null, "http://castor.exolab.org/");
marshal.setNamespaceMapping("cst", "http://castor.exolab.org/");
marshal.marshal(mapping);
} catch (Exception except) {
throw new MappingException(except);
}
} // -- write
/**
* To set the XMLContext to be used.
* @param internalContext the XMLContext to be used
*/
public void setInternalContext(final InternalContext internalContext) {
_internalContext = internalContext;
_mappings = new Hashtable();
_mappingLoader = new MappingToolMappingLoader(_internalContext.getJavaNaming());
}
} // -- MappingTool