/**
* $Id: mxObjectCodec.java,v 1.1 2012/11/15 13:26:47 gaudenz Exp $
* Copyright (c) 2006, Gaudenz Alder
*/
package com.mxgraph.io;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import com.mxgraph.util.mxUtils;
/**
* Generic codec for Java objects. See below for a detailed description of
* the encoding/decoding scheme.
*
* Note: Since booleans are numbers in JavaScript, all boolean values are
* encoded into 1 for true and 0 for false.
*/
@SuppressWarnings("unchecked")
public class mxObjectCodec
{
/**
* Immutable empty set.
*/
private static Set<String> EMPTY_SET = new HashSet<String>();
/**
* Holds the template object associated with this codec.
*/
protected Object template;
/**
* Array containing the variable names that should be ignored by the codec.
*/
protected Set<String> exclude;
/**
* Array containing the variable names that should be turned into or
* converted from references. See <mxCodec.getId> and <mxCodec.getObject>.
*/
protected Set<String> idrefs;
/**
* Maps from from fieldnames to XML attribute names.
*/
protected Map<String, String> mapping;
/**
* Maps from from XML attribute names to fieldnames.
*/
protected Map<String, String> reverse;
/**
* Caches accessors for the given method names.
*/
protected Map<String, Method> accessors;
/**
* Caches fields for faster access.
*/
protected Map<Class, Map<String, Field>> fields;
/**
* Constructs a new codec for the specified template object.
*/
public mxObjectCodec(Object template)
{
this(template, null, null, null);
}
/**
* Constructs a new codec for the specified template object. The variables
* in the optional exclude array are ignored by the codec. Variables in the
* optional idrefs array are turned into references in the XML. The
* optional mapping may be used to map from variable names to XML
* attributes. The argument is created as follows:
*
* @param template Prototypical instance of the object to be encoded/decoded.
* @param exclude Optional array of fieldnames to be ignored.
* @param idrefs Optional array of fieldnames to be converted to/from references.
* @param mapping Optional mapping from field- to attributenames.
*/
public mxObjectCodec(Object template, String[] exclude, String[] idrefs,
Map<String, String> mapping)
{
this.template = template;
if (exclude != null)
{
this.exclude = new HashSet<String>();
for (int i = 0; i < exclude.length; i++)
{
this.exclude.add(exclude[i]);
}
}
else
{
this.exclude = EMPTY_SET;
}
if (idrefs != null)
{
this.idrefs = new HashSet<String>();
for (int i = 0; i < idrefs.length; i++)
{
this.idrefs.add(idrefs[i]);
}
}
else
{
this.idrefs = EMPTY_SET;
}
if (mapping == null)
{
mapping = new Hashtable<String, String>();
}
this.mapping = mapping;
reverse = new Hashtable<String, String>();
Iterator<Map.Entry<String, String>> it = mapping.entrySet().iterator();
while (it.hasNext())
{
Map.Entry<String, String> e = it.next();
reverse.put(e.getValue(), e.getKey());
}
}
/**
* Returns the name used for the nodenames and lookup of the codec when
* classes are encoded and nodes are decoded. For classes to work with
* this the codec registry automatically adds an alias for the classname
* if that is different than what this returns. The default implementation
* returns the classname of the template class.
*
* Here is an example on how to use this for renaming mxCell nodes:
* <code>
* mxCodecRegistry.register(new mxCellCodec()
* {
* public String getName()
* {
* return "anotherName";
* }
* });
* </code>
*/
public String getName()
{
return mxCodecRegistry.getName(getTemplate());
}
/**
* Returns the template object associated with this codec.
*
* @return Returns the template object.
*/
public Object getTemplate()
{
return template;
}
/**
* Returns a new instance of the template object for representing the given
* node.
*
* @param node XML node that the object is going to represent.
* @return Returns a new template instance.
*/
protected Object cloneTemplate(Node node)
{
Object obj = null;
try
{
if (template.getClass().isEnum())
{
obj = template.getClass().getEnumConstants()[0];
}
else
{
obj = template.getClass().newInstance();
}
// Special case: Check if the collection
// should be a map. This is if the first
// child has an "as"-attribute. This
// assumes that all childs will have
// as attributes in this case. This is
// required because in JavaScript, the
// map and array object are the same.
if (obj instanceof Collection)
{
node = node.getFirstChild();
// Skips text nodes
while (node != null && !(node instanceof Element))
{
node = node.getNextSibling();
}
if (node != null && node instanceof Element
&& ((Element) node).hasAttribute("as"))
{
obj = new Hashtable<Object, Object>();
}
}
}
catch (InstantiationException e)
{
// ignore
e.printStackTrace();
}
catch (IllegalAccessException e)
{
// ignore
e.printStackTrace();
}
return obj;
}
/**
* Returns true if the given attribute is to be ignored by the codec. This
* implementation returns true if the given fieldname is in
* {@link #exclude}.
*
* @param obj Object instance that contains the field.
* @param attr Fieldname of the field.
* @param value Value of the field.
* @param write Boolean indicating if the field is being encoded or
* decoded. write is true if the field is being encoded, else it is
* being decoded.
* @return Returns true if the given attribute should be ignored.
*/
public boolean isExcluded(Object obj, String attr, Object value,
boolean write)
{
return exclude.contains(attr);
}
/**
* Returns true if the given fieldname is to be treated as a textual
* reference (ID). This implementation returns true if the given fieldname
* is in {@link #idrefs}.
*
* @param obj Object instance that contains the field.
* @param attr Fieldname of the field.
* @param value Value of the field.
* @param isWrite Boolean indicating if the field is being encoded or
* decoded. isWrite is true if the field is being encoded, else it is being
* decoded.
* @return Returns true if the given attribute should be handled as a
* reference.
*/
public boolean isReference(Object obj, String attr, Object value,
boolean isWrite)
{
return idrefs.contains(attr);
}
/**
* Encodes the specified object and returns a node representing then given
* object. Calls beforeEncode after creating the node and afterEncode
* with the resulting node after processing.
*
* Enc is a reference to the calling encoder. It is used to encode complex
* objects and create references.
*
* This implementation encodes all variables of an object according to the
* following rules:
*
* <ul>
* <li>If the variable name is in {@link #exclude} then it is ignored.</li>
* <li>If the variable name is in {@link #idrefs} then
* {@link mxCodec#getId(Object)} is used to replace the object with its ID.
* </li>
* <li>The variable name is mapped using {@link #mapping}.</li>
* <li>If obj is an array and the variable name is numeric (ie. an index) then it
* is not encoded.</li>
* <li>If the value is an object, then the codec is used to create a child
* node with the variable name encoded into the "as" attribute.</li>
* <li>Else, if {@link com.mxgraph.io.mxCodec#isEncodeDefaults()} is true or
* the value differs from the template value, then ...
* <ul>
* <li>... if obj is not an array, then the value is mapped to an
* attribute.</li>
* <li>... else if obj is an array, the value is mapped to an add child
* with a value attribute or a text child node, if the value is a function.
* </li>
* </ul>
* </li>
* </ul>
*
* If no ID exists for a variable in {@link #idrefs} or if an object cannot be
* encoded, a warning is printed to System.err.
*
* @param enc Codec that controls the encoding process.
* @param obj Object to be encoded.
* @return Returns the resulting XML node that represents the given object.
*/
public Node encode(mxCodec enc, Object obj)
{
Node node = enc.document.createElement(getName());
obj = beforeEncode(enc, obj, node);
encodeObject(enc, obj, node);
return afterEncode(enc, obj, node);
}
/**
* Encodes the value of each member in then given obj
* into the given node using {@link #encodeFields(mxCodec, Object, Node)}
* and {@link #encodeElements(mxCodec, Object, Node)}.
*
* @param enc Codec that controls the encoding process.
* @param obj Object to be encoded.
* @param node XML node that contains the encoded object.
*/
protected void encodeObject(mxCodec enc, Object obj, Node node)
{
mxCodec.setAttribute(node, "id", enc.getId(obj));
encodeFields(enc, obj, node);
encodeElements(enc, obj, node);
}
/**
* Encodes the declared fields of the given object into the given node.
*
* @param enc Codec that controls the encoding process.
* @param obj Object whose fields should be encoded.
* @param node XML node that contains the encoded object.
*/
protected void encodeFields(mxCodec enc, Object obj, Node node)
{
// LATER: Use PropertyDescriptors in Introspector.getBeanInfo(clazz)
// see http://forum.jgraph.com/questions/1424
Class<?> type = obj.getClass();
while (type != null)
{
Field[] fields = type.getDeclaredFields();
for (int i = 0; i < fields.length; i++)
{
Field f = fields[i];
if ((f.getModifiers() & Modifier.TRANSIENT) != Modifier.TRANSIENT)
{
String fieldname = f.getName();
Object value = getFieldValue(obj, fieldname);
encodeValue(enc, obj, fieldname, value, node);
}
}
type = type.getSuperclass();
}
}
/**
* Encodes the child objects of arrays, maps and collections.
*
* @param enc Codec that controls the encoding process.
* @param obj Object whose child objects should be encoded.
* @param node XML node that contains the encoded object.
*/
protected void encodeElements(mxCodec enc, Object obj, Node node)
{
if (obj.getClass().isArray())
{
Object[] tmp = (Object[]) obj;
for (int i = 0; i < tmp.length; i++)
{
encodeValue(enc, obj, null, tmp[i], node);
}
}
else if (obj instanceof Map)
{
Iterator<Map.Entry> it = ((Map) obj).entrySet().iterator();
while (it.hasNext())
{
Map.Entry e = it.next();
encodeValue(enc, obj, String.valueOf(e.getKey()), e.getValue(),
node);
}
}
else if (obj instanceof Collection)
{
Iterator<?> it = ((Collection<?>) obj).iterator();
while (it.hasNext())
{
Object value = it.next();
encodeValue(enc, obj, null, value, node);
}
}
}
/**
* Converts the given value according to the mappings
* and id-refs in this codec and uses
* {@link #writeAttribute(mxCodec, Object, String, Object, Node)}
* to write the attribute into the given node.
*
* @param enc Codec that controls the encoding process.
* @param obj Object whose field is going to be encoded.
* @param fieldname Name if the field to be encoded.
* @param value Value of the property to be encoded.
* @param node XML node that contains the encoded object.
*/
protected void encodeValue(mxCodec enc, Object obj, String fieldname,
Object value, Node node)
{
if (value != null && !isExcluded(obj, fieldname, value, true))
{
if (isReference(obj, fieldname, value, true))
{
Object tmp = enc.getId(value);
if (tmp == null)
{
System.err.println("mxObjectCodec.encode: No ID for "
+ getName() + "." + fieldname + "=" + value);
return; // exit
}
value = tmp;
}
Object defaultValue = getFieldValue(template, fieldname);
if (fieldname == null || enc.isEncodeDefaults()
|| defaultValue == null || !defaultValue.equals(value))
{
writeAttribute(enc, obj, getAttributeName(fieldname), value,
node);
}
}
}
/**
* Returns true if the given object is a primitive value.
*
* @param value Object that should be checked.
* @return Returns true if the given object is a primitive value.
*/
protected boolean isPrimitiveValue(Object value)
{
return value instanceof String || value instanceof Boolean
|| value instanceof Character || value instanceof Byte
|| value instanceof Short || value instanceof Integer
|| value instanceof Long || value instanceof Float
|| value instanceof Double || value.getClass().isPrimitive();
}
/**
* Writes the given value into node using writePrimitiveAttribute
* or writeComplexAttribute depending on the type of the value.
*/
protected void writeAttribute(mxCodec enc, Object obj, String attr,
Object value, Node node)
{
value = convertValueToXml(value);
if (isPrimitiveValue(value))
{
writePrimitiveAttribute(enc, obj, attr, value, node);
}
else
{
writeComplexAttribute(enc, obj, attr, value, node);
}
}
/**
* Writes the given value as an attribute of the given node.
*/
protected void writePrimitiveAttribute(mxCodec enc, Object obj,
String attr, Object value, Node node)
{
if (attr == null || obj instanceof Map)
{
Node child = enc.document.createElement("add");
if (attr != null)
{
mxCodec.setAttribute(child, "as", attr);
}
mxCodec.setAttribute(child, "value", value);
node.appendChild(child);
}
else
{
mxCodec.setAttribute(node, attr, value);
}
}
/**
* Writes the given value as a child node of the given node.
*/
protected void writeComplexAttribute(mxCodec enc, Object obj, String attr,
Object value, Node node)
{
Node child = enc.encode(value);
if (child != null)
{
if (attr != null)
{
mxCodec.setAttribute(child, "as", attr);
}
node.appendChild(child);
}
else
{
System.err.println("mxObjectCodec.encode: No node for " + getName()
+ "." + attr + ": " + value);
}
}
/**
* Converts true to "1" and false to "0". All other values are ignored.
*/
protected Object convertValueToXml(Object value)
{
if (value instanceof Boolean)
{
value = ((Boolean) value).booleanValue() ? "1" : "0";
}
return value;
}
/**
* Converts XML attribute values to object of the given type.
*/
protected Object convertValueFromXml(Class<?> type, Object value)
{
if (value instanceof String)
{
String tmp = (String) value;
if (type.equals(boolean.class) || type == Boolean.class)
{
if (tmp.equals("1") || tmp.equals("0"))
{
tmp = (tmp.equals("1")) ? "true" : "false";
}
value = Boolean.valueOf(tmp);
}
else if (type.equals(char.class) || type == Character.class)
{
value = Character.valueOf(tmp.charAt(0));
}
else if (type.equals(byte.class) || type == Byte.class)
{
value = Byte.valueOf(tmp);
}
else if (type.equals(short.class) || type == Short.class)
{
value = Short.valueOf(tmp);
}
else if (type.equals(int.class) || type == Integer.class)
{
value = Integer.valueOf(tmp);
}
else if (type.equals(long.class) || type == Long.class)
{
value = Long.valueOf(tmp);
}
else if (type.equals(float.class) || type == Float.class)
{
value = Float.valueOf(tmp);
}
else if (type.equals(double.class) || type == Double.class)
{
value = Double.valueOf(tmp);
}
}
return value;
}
/**
* Returns the XML node attribute name for the given Java field name. That
* is, it returns the mapping of the field name.
*/
protected String getAttributeName(String fieldname)
{
if (fieldname != null)
{
Object mapped = mapping.get(fieldname);
if (mapped != null)
{
fieldname = mapped.toString();
}
}
return fieldname;
}
/**
* Returns the Java field name for the given XML attribute name. That is, it
* returns the reverse mapping of the attribute name.
*
* @param attributename
* The attribute name to be mapped.
* @return String that represents the mapped field name.
*/
protected String getFieldName(String attributename)
{
if (attributename != null)
{
Object mapped = reverse.get(attributename);
if (mapped != null)
{
attributename = mapped.toString();
}
}
return attributename;
}
/**
* Returns the field with the specified name.
*/
protected Field getField(Object obj, String fieldname)
{
Class<?> type = obj.getClass();
// Creates the fields cache
if (fields == null)
{
fields = new HashMap<Class, Map<String, Field>>();
}
// Creates the fields cache entry for the given type
Map<String, Field> map = fields.get(type);
if (map == null)
{
map = new HashMap<String, Field>();
fields.put(type, map);
}
// Tries to get cached field
Field field = map.get(fieldname);
if (field != null)
{
return field;
}
while (type != null)
{
try
{
field = type.getDeclaredField(fieldname);
if (field != null)
{
// Adds field to fields cache
map.put(fieldname, field);
return field;
}
}
catch (Exception e)
{
// ignore
}
type = type.getSuperclass();
}
return null;
}
/**
* Returns the accessor (getter, setter) for the specified field.
*/
protected Method getAccessor(Object obj, Field field, boolean isGetter)
{
String name = field.getName();
name = name.substring(0, 1).toUpperCase() + name.substring(1);
if (!isGetter)
{
name = "set" + name;
}
else if (boolean.class.isAssignableFrom(field.getType()))
{
name = "is" + name;
}
else
{
name = "get" + name;
}
Method method = (accessors != null) ? accessors.get(name) : null;
if (method == null)
{
try
{
if (isGetter)
{
method = getMethod(obj, name, null);
}
else
{
method = getMethod(obj, name,
new Class[] { field.getType() });
}
}
catch (Exception e1)
{
// ignore
}
// Adds accessor to cache
if (method != null)
{
if (accessors == null)
{
accessors = new Hashtable<String, Method>();
}
accessors.put(name, method);
}
}
return method;
}
/**
* Returns the method with the specified signature.
*/
protected Method getMethod(Object obj, String methodname, Class[] params)
{
Class<?> type = obj.getClass();
while (type != null)
{
try
{
Method method = type.getDeclaredMethod(methodname, params);
if (method != null)
{
return method;
}
}
catch (Exception e)
{
// ignore
}
type = type.getSuperclass();
}
return null;
}
/**
* Returns the value of the field with the specified name in the specified
* object instance.
*/
protected Object getFieldValue(Object obj, String fieldname)
{
Object value = null;
if (obj != null && fieldname != null)
{
Field field = getField(obj, fieldname);
try
{
if (field != null)
{
if (Modifier.isPublic(field.getModifiers()))
{
value = field.get(obj);
}
else
{
value = getFieldValueWithAccessor(obj, field);
}
}
}
catch (IllegalAccessException e1)
{
value = getFieldValueWithAccessor(obj, field);
}
catch (Exception e)
{
// ignore
}
}
return value;
}
/**
* Returns the value of the field using the accessor for the field if one exists.
*/
protected Object getFieldValueWithAccessor(Object obj, Field field)
{
Object value = null;
if (field != null)
{
try
{
Method method = getAccessor(obj, field, true);
if (method != null)
{
value = method.invoke(obj, (Object[]) null);
}
}
catch (Exception e2)
{
// ignore
}
}
return value;
}
/**
* Sets the value of the field with the specified name
* in the specified object instance.
*/
protected void setFieldValue(Object obj, String fieldname, Object value)
{
Field field = null;
try
{
field = getField(obj, fieldname);
if (field != null)
{
if (field.getType() == Boolean.class)
{
value = (value.equals("1") || String.valueOf(value)
.equalsIgnoreCase("true")) ? Boolean.TRUE
: Boolean.FALSE;
}
if (Modifier.isPublic(field.getModifiers()))
{
field.set(obj, value);
}
else
{
setFieldValueWithAccessor(obj, field, value);
}
}
}
catch (IllegalAccessException e1)
{
setFieldValueWithAccessor(obj, field, value);
}
catch (Exception e)
{
// ignore
}
}
/**
* Sets the value of the given field using the accessor if one exists.
*/
protected void setFieldValueWithAccessor(Object obj, Field field,
Object value)
{
if (field != null)
{
try
{
Method method = getAccessor(obj, field, false);
if (method != null)
{
Class<?> type = method.getParameterTypes()[0];
value = convertValueFromXml(type, value);
// Converts collection to a typed array before setting
if (type.isArray() && value instanceof Collection)
{
Collection<?> coll = (Collection<?>) value;
value = coll.toArray((Object[]) Array.newInstance(
type.getComponentType(), coll.size()));
}
method.invoke(obj, new Object[] { value });
}
}
catch (Exception e2)
{
System.err.println("setFieldValue: " + e2 + " on "
+ obj.getClass().getSimpleName() + "."
+ field.getName() + " ("
+ field.getType().getSimpleName() + ") = " + value
+ " (" + value.getClass().getSimpleName() + ")");
}
}
}
/**
* Hook for subclassers to pre-process the object before encoding. This
* returns the input object. The return value of this function is used in
* encode to perform the default encoding into the given node.
*
* @param enc Codec that controls the encoding process.
* @param obj Object to be encoded.
* @param node XML node to encode the object into.
* @return Returns the object to be encoded by the default encoding.
*/
public Object beforeEncode(mxCodec enc, Object obj, Node node)
{
return obj;
}
/**
* Hook for subclassers to post-process the node for the given object after
* encoding and return the post-processed node. This implementation returns
* the input node. The return value of this method is returned to the
* encoder from <encode>.
*
* Parameters:
*
* @param enc Codec that controls the encoding process.
* @param obj Object to be encoded.
* @param node XML node that represents the default encoding.
* @return Returns the resulting node of the encoding.
*/
public Node afterEncode(mxCodec enc, Object obj, Node node)
{
return node;
}
/**
* Parses the given node into the object or returns a new object
* representing the given node.
*
* @param dec Codec that controls the encoding process.
* @param node XML node to be decoded.
* @return Returns the resulting object that represents the given XML node.
*/
public Object decode(mxCodec dec, Node node)
{
return decode(dec, node, null);
}
/**
* Parses the given node into the object or returns a new object
* representing the given node.
*
* Dec is a reference to the calling decoder. It is used to decode complex
* objects and resolve references.
*
* If a node has an id attribute then the object cache is checked for the
* object. If the object is not yet in the cache then it is constructed
* using the constructor of <template> and cached in <mxCodec.objects>.
*
* This implementation decodes all attributes and childs of a node according
* to the following rules:
* - If the variable name is in <exclude> or if the attribute name is "id"
* or "as" then it is ignored. - If the variable name is in <idrefs> then
* <mxCodec.getObject> is used to replace the reference with an object. -
* The variable name is mapped using a reverse <mapping>. - If the value has
* a child node, then the codec is used to create a child object with the
* variable name taken from the "as" attribute. - If the object is an array
* and the variable name is empty then the value or child object is appended
* to the array. - If an add child has no value or the object is not an
* array then the child text content is evaluated using <mxUtils.eval>.
*
* If no object exists for an ID in <idrefs> a warning is issued in
* System.err.
*
* @param dec Codec that controls the encoding process.
* @param node XML node to be decoded.
* @param into Optional object to encode the node into.
* @return Returns the resulting object that represents the given XML node
* or the object given to the method as the into parameter.
*/
public Object decode(mxCodec dec, Node node, Object into)
{
Object obj = null;
if (node instanceof Element)
{
String id = ((Element) node).getAttribute("id");
obj = dec.objects.get(id);
if (obj == null)
{
obj = into;
if (obj == null)
{
obj = cloneTemplate(node);
}
if (id != null && id.length() > 0)
{
dec.putObject(id, obj);
}
}
node = beforeDecode(dec, node, obj);
decodeNode(dec, node, obj);
obj = afterDecode(dec, node, obj);
}
return obj;
}
/**
* Calls decodeAttributes and decodeChildren for the given node.
*/
protected void decodeNode(mxCodec dec, Node node, Object obj)
{
if (node != null)
{
decodeAttributes(dec, node, obj);
decodeChildren(dec, node, obj);
}
}
/**
* Decodes all attributes of the given node using decodeAttribute.
*/
protected void decodeAttributes(mxCodec dec, Node node, Object obj)
{
NamedNodeMap attrs = node.getAttributes();
if (attrs != null)
{
for (int i = 0; i < attrs.getLength(); i++)
{
Node attr = attrs.item(i);
decodeAttribute(dec, attr, obj);
}
}
}
/**
* Reads the given attribute into the specified object.
*/
protected void decodeAttribute(mxCodec dec, Node attr, Object obj)
{
String name = attr.getNodeName();
if (!name.equalsIgnoreCase("as") && !name.equalsIgnoreCase("id"))
{
Object value = attr.getNodeValue();
String fieldname = getFieldName(name);
if (isReference(obj, fieldname, value, false))
{
Object tmp = dec.getObject(String.valueOf(value));
if (tmp == null)
{
System.err.println("mxObjectCodec.decode: No object for "
+ getName() + "." + fieldname + "=" + value);
return; // exit
}
value = tmp;
}
if (!isExcluded(obj, fieldname, value, false))
{
setFieldValue(obj, fieldname, value);
}
}
}
/**
* Decodec all children of the given node using decodeChild.
*/
protected void decodeChildren(mxCodec dec, Node node, Object obj)
{
Node child = node.getFirstChild();
while (child != null)
{
if (child.getNodeType() == Node.ELEMENT_NODE
&& !processInclude(dec, child, obj))
{
decodeChild(dec, child, obj);
}
child = child.getNextSibling();
}
}
/**
* Reads the specified child into the given object.
*/
protected void decodeChild(mxCodec dec, Node child, Object obj)
{
String fieldname = getFieldName(((Element) child).getAttribute("as"));
if (fieldname == null || !isExcluded(obj, fieldname, child, false))
{
Object template = getFieldTemplate(obj, fieldname, child);
Object value = null;
if (child.getNodeName().equals("add"))
{
value = ((Element) child).getAttribute("value");
if (value == null)
{
value = child.getTextContent();
}
}
else
{
value = dec.decode(child, template);
// System.out.println("Decoded " + child.getNodeName() + "."
// + fieldname + "=" + value);
}
addObjectValue(obj, fieldname, value, template);
}
}
/**
* Returns the template instance for the given field. This returns the
* value of the field, null if the value is an array or an empty collection
* if the value is a collection. The value is then used to populate the
* field for a new instance. For strongly typed languages it may be
* required to override this to return the correct collection instance
* based on the encoded child.
*/
protected Object getFieldTemplate(Object obj, String fieldname, Node child)
{
Object template = getFieldValue(obj, fieldname);
// Arrays are replaced completely
if (template != null && template.getClass().isArray())
{
template = null;
}
// Collections are cleared
else if (template instanceof Collection)
{
((Collection<?>) template).clear();
}
return template;
}
/**
* Sets the decoded child node as a value of the given object. If the
* object is a map, then the value is added with the given fieldname as a
* key. If the fieldname is not empty, then setFieldValue is called or
* else, if the object is a collection, the value is added to the
* collection. For strongly typed languages it may be required to
* override this with the correct code to add an entry to an object.
*/
protected void addObjectValue(Object obj, String fieldname, Object value,
Object template)
{
if (value != null && !value.equals(template))
{
if (fieldname != null && obj instanceof Map)
{
((Map) obj).put(fieldname, value);
}
else if (fieldname != null && fieldname.length() > 0)
{
setFieldValue(obj, fieldname, value);
}
// Arrays are treated as collections and
// converted in setFieldValue
else if (obj instanceof Collection)
{
((Collection) obj).add(value);
}
}
}
/**
* Returns true if the given node is an include directive and executes the
* include by decoding the XML document. Returns false if the given node is
* not an include directive.
*
* @param dec Codec that controls the encoding/decoding process.
* @param node XML node to be checked.
* @param into Optional object to pass-thru to the codec.
* @return Returns true if the given node was processed as an include.
*/
public boolean processInclude(mxCodec dec, Node node, Object into)
{
if (node.getNodeType() == Node.ELEMENT_NODE
&& node.getNodeName().equalsIgnoreCase("include"))
{
String name = ((Element) node).getAttribute("name");
if (name != null)
{
try
{
Node xml = mxUtils.loadDocument(
mxObjectCodec.class.getResource(name).toString())
.getDocumentElement();
if (xml != null)
{
dec.decode(xml, into);
}
}
catch (Exception e)
{
System.err.println("Cannot process include: " + name);
}
}
return true;
}
return false;
}
/**
* Hook for subclassers to pre-process the node for the specified object
* and return the node to be used for further processing by
* {@link #decode(mxCodec, Node)}. The object is created based on the
* template in the calling method and is never null.
*
* This implementation returns the input node. The return value of this
* function is used in {@link #decode(mxCodec, Node)} to perform the
* default decoding into the given object.
*
* @param dec Codec that controls the decoding process.
* @param node XML node to be decoded.
* @param obj Object to encode the node into.
* @return Returns the node used for the default decoding.
*/
public Node beforeDecode(mxCodec dec, Node node, Object obj)
{
return node;
}
/**
* Hook for subclassers to post-process the object after decoding. This
* implementation returns the given object without any changes. The return
* value of this method is returned to the decoder from
* {@link #decode(mxCodec, Node)}.
*
* @param dec Codec that controls the decoding process.
* @param node XML node to be decoded.
* @param obj Object that represents the default decoding.
* @return Returns the result of the decoding process.
*/
public Object afterDecode(mxCodec dec, Node node, Object obj)
{
return obj;
}
}