package com.mxgraph.io;
|
|
import com.mxgraph.util.mxUtils;
|
import java.io.PrintStream;
|
import java.lang.reflect.Array;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.Method;
|
import java.net.URL;
|
import java.util.Collection;
|
import java.util.HashSet;
|
import java.util.Hashtable;
|
import java.util.Iterator;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.Set;
|
import org.w3c.dom.Document;
|
import org.w3c.dom.Element;
|
import org.w3c.dom.NamedNodeMap;
|
import org.w3c.dom.Node;
|
|
public class mxObjectCodec
|
{
|
private static Set<String> EMPTY_SET = new HashSet();
|
protected Object template;
|
protected Set<String> exclude;
|
protected Set<String> idrefs;
|
protected Map<String, String> mapping;
|
protected Map<String, String> reverse;
|
|
public mxObjectCodec(Object paramObject)
|
{
|
this(paramObject, null, null, null);
|
}
|
|
public mxObjectCodec(Object paramObject, String[] paramArrayOfString1, String[] paramArrayOfString2, Map<String, String> paramMap)
|
{
|
this.template = paramObject;
|
int i;
|
if (paramArrayOfString1 != null)
|
{
|
this.exclude = new HashSet();
|
for (i = 0; i < paramArrayOfString1.length; ++i)
|
this.exclude.add(paramArrayOfString1[i]);
|
}
|
else
|
{
|
this.exclude = EMPTY_SET;
|
}
|
if (paramArrayOfString2 != null)
|
{
|
this.idrefs = new HashSet();
|
for (i = 0; i < paramArrayOfString2.length; ++i)
|
this.idrefs.add(paramArrayOfString2[i]);
|
}
|
else
|
{
|
this.idrefs = EMPTY_SET;
|
}
|
if (paramMap == null)
|
paramMap = new Hashtable();
|
this.mapping = paramMap;
|
this.reverse = new Hashtable();
|
Iterator localIterator = paramMap.entrySet().iterator();
|
while (localIterator.hasNext())
|
{
|
Map.Entry localEntry = (Map.Entry)localIterator.next();
|
this.reverse.put(localEntry.getValue(), localEntry.getKey());
|
}
|
}
|
|
public String getName()
|
{
|
return mxCodecRegistry.getName(getTemplate());
|
}
|
|
public Object getTemplate()
|
{
|
return this.template;
|
}
|
|
protected Object cloneTemplate(Node paramNode)
|
{
|
Object localObject = null;
|
try
|
{
|
if (this.template.getClass().isEnum())
|
localObject = this.template.getClass().getEnumConstants()[0];
|
else
|
localObject = this.template.getClass().newInstance();
|
if (localObject instanceof Collection)
|
{
|
paramNode = paramNode.getFirstChild();
|
if ((paramNode != null) && (paramNode instanceof Element) && (((Element)paramNode).hasAttribute("as")))
|
localObject = new Hashtable();
|
}
|
}
|
catch (InstantiationException localInstantiationException)
|
{
|
localInstantiationException.printStackTrace();
|
}
|
catch (IllegalAccessException localIllegalAccessException)
|
{
|
localIllegalAccessException.printStackTrace();
|
}
|
return localObject;
|
}
|
|
public boolean isExcluded(Object paramObject1, String paramString, Object paramObject2, boolean paramBoolean)
|
{
|
return this.exclude.contains(paramString);
|
}
|
|
public boolean isReference(Object paramObject1, String paramString, Object paramObject2, boolean paramBoolean)
|
{
|
return this.idrefs.contains(paramString);
|
}
|
|
public Node encode(mxCodec parammxCodec, Object paramObject)
|
{
|
Element localElement = parammxCodec.document.createElement(getName());
|
paramObject = beforeEncode(parammxCodec, paramObject, localElement);
|
encodeObject(parammxCodec, paramObject, localElement);
|
return afterEncode(parammxCodec, paramObject, localElement);
|
}
|
|
protected void encodeObject(mxCodec parammxCodec, Object paramObject, Node paramNode)
|
{
|
mxCodec.setAttribute(paramNode, "id", parammxCodec.getId(paramObject));
|
encodeFields(parammxCodec, paramObject, paramNode);
|
encodeElements(parammxCodec, paramObject, paramNode);
|
}
|
|
protected void encodeFields(mxCodec parammxCodec, Object paramObject, Node paramNode)
|
{
|
for (Class localClass = paramObject.getClass(); localClass != null; localClass = localClass.getSuperclass())
|
{
|
Field[] arrayOfField = localClass.getDeclaredFields();
|
for (int i = 0; i < arrayOfField.length; ++i)
|
{
|
Field localField = arrayOfField[i];
|
if ((localField.getModifiers() & 0x80) == 128)
|
continue;
|
String str = localField.getName();
|
Object localObject = getFieldValue(paramObject, str);
|
encodeValue(parammxCodec, paramObject, str, localObject, paramNode);
|
}
|
}
|
}
|
|
protected void encodeElements(mxCodec parammxCodec, Object paramObject, Node paramNode)
|
{
|
Object localObject1;
|
if (paramObject.getClass().isArray())
|
{
|
localObject1 = (Object[])(Object[])paramObject;
|
for (int i = 0; i < localObject1.length; ++i)
|
encodeValue(parammxCodec, paramObject, null, localObject1[i], paramNode);
|
}
|
else
|
{
|
Object localObject2;
|
if (paramObject instanceof Map)
|
{
|
localObject1 = ((Map)paramObject).entrySet().iterator();
|
while (((Iterator)localObject1).hasNext())
|
{
|
localObject2 = (Map.Entry)((Iterator)localObject1).next();
|
encodeValue(parammxCodec, paramObject, String.valueOf(((Map.Entry)localObject2).getKey()), ((Map.Entry)localObject2).getValue(), paramNode);
|
}
|
}
|
else
|
{
|
if (!(paramObject instanceof Collection))
|
return;
|
localObject1 = ((Collection)paramObject).iterator();
|
while (((Iterator)localObject1).hasNext())
|
{
|
localObject2 = ((Iterator)localObject1).next();
|
encodeValue(parammxCodec, paramObject, null, localObject2, paramNode);
|
}
|
}
|
}
|
}
|
|
protected void encodeValue(mxCodec parammxCodec, Object paramObject1, String paramString, Object paramObject2, Node paramNode)
|
{
|
if ((paramObject2 == null) || (isExcluded(paramObject1, paramString, paramObject2, true)))
|
return;
|
if (isReference(paramObject1, paramString, paramObject2, true))
|
{
|
localObject = parammxCodec.getId(paramObject2);
|
if (localObject == null)
|
{
|
System.err.println("mxObjectCodec.encode: No ID for " + getName() + "." + paramString + "=" + paramObject2);
|
return;
|
}
|
paramObject2 = localObject;
|
}
|
Object localObject = getFieldValue(this.template, paramString);
|
if ((paramString != null) && (!(parammxCodec.isEncodeDefaults())) && (localObject != null) && (localObject.equals(paramObject2)))
|
return;
|
writeAttribute(parammxCodec, paramObject1, getAttributeName(paramString), paramObject2, paramNode);
|
}
|
|
protected boolean isPrimitiveValue(Object paramObject)
|
{
|
return ((paramObject instanceof String) || (paramObject instanceof Boolean) || (paramObject instanceof Character) || (paramObject instanceof Byte) || (paramObject instanceof Short) || (paramObject instanceof Integer) || (paramObject instanceof Long) || (paramObject instanceof Float) || (paramObject instanceof Double) || (paramObject.getClass().isPrimitive()));
|
}
|
|
protected void writeAttribute(mxCodec parammxCodec, Object paramObject1, String paramString, Object paramObject2, Node paramNode)
|
{
|
paramObject2 = convertValueToXml(paramObject2);
|
if (isPrimitiveValue(paramObject2))
|
writePrimitiveAttribute(parammxCodec, paramObject1, paramString, paramObject2, paramNode);
|
else
|
writeComplexAttribute(parammxCodec, paramObject1, paramString, paramObject2, paramNode);
|
}
|
|
protected void writePrimitiveAttribute(mxCodec parammxCodec, Object paramObject1, String paramString, Object paramObject2, Node paramNode)
|
{
|
if ((paramString == null) || (paramObject1 instanceof Map))
|
{
|
Element localElement = parammxCodec.document.createElement("add");
|
if (paramString != null)
|
mxCodec.setAttribute(localElement, "as", paramString);
|
mxCodec.setAttribute(localElement, "value", paramObject2);
|
paramNode.appendChild(localElement);
|
}
|
else
|
{
|
mxCodec.setAttribute(paramNode, paramString, paramObject2);
|
}
|
}
|
|
protected void writeComplexAttribute(mxCodec parammxCodec, Object paramObject1, String paramString, Object paramObject2, Node paramNode)
|
{
|
Node localNode = parammxCodec.encode(paramObject2);
|
if (localNode != null)
|
{
|
if (paramString != null)
|
mxCodec.setAttribute(localNode, "as", paramString);
|
paramNode.appendChild(localNode);
|
}
|
else
|
{
|
System.err.println("mxObjectCodec.encode: No node for " + getName() + "." + paramString + ": " + paramObject2);
|
}
|
}
|
|
protected Object convertValueToXml(Object paramObject)
|
{
|
if (paramObject instanceof Boolean)
|
paramObject = (((Boolean)paramObject).booleanValue()) ? "1" : "0";
|
return paramObject;
|
}
|
|
protected Object convertValueFromXml(Class<?> paramClass, Object paramObject)
|
{
|
if (paramObject instanceof String)
|
{
|
String str = (String)paramObject;
|
if ((paramClass.equals(Boolean.TYPE)) || (paramClass == Boolean.class))
|
{
|
if ((str.equals("1")) || (str.equals("0")))
|
str = (str.equals("1")) ? "true" : "false";
|
paramObject = Boolean.valueOf(str);
|
}
|
else if ((paramClass.equals(Character.TYPE)) || (paramClass == Character.class))
|
{
|
paramObject = Character.valueOf(str.charAt(0));
|
}
|
else if ((paramClass.equals(Byte.TYPE)) || (paramClass == Byte.class))
|
{
|
paramObject = Byte.valueOf(str);
|
}
|
else if ((paramClass.equals(Short.TYPE)) || (paramClass == Short.class))
|
{
|
paramObject = Short.valueOf(str);
|
}
|
else if ((paramClass.equals(Integer.TYPE)) || (paramClass == Integer.class))
|
{
|
paramObject = Integer.valueOf(str);
|
}
|
else if ((paramClass.equals(Long.TYPE)) || (paramClass == Long.class))
|
{
|
paramObject = Long.valueOf(str);
|
}
|
else if ((paramClass.equals(Float.TYPE)) || (paramClass == Float.class))
|
{
|
paramObject = Float.valueOf(str);
|
}
|
else if ((paramClass.equals(Double.TYPE)) || (paramClass == Double.class))
|
{
|
paramObject = Double.valueOf(str);
|
}
|
}
|
return paramObject;
|
}
|
|
protected String getAttributeName(String paramString)
|
{
|
if (paramString != null)
|
{
|
Object localObject = this.mapping.get(paramString);
|
if (localObject != null)
|
paramString = localObject.toString();
|
}
|
return paramString;
|
}
|
|
protected String getFieldName(String paramString)
|
{
|
if (paramString != null)
|
{
|
Object localObject = this.reverse.get(paramString);
|
if (localObject != null)
|
paramString = localObject.toString();
|
}
|
return paramString;
|
}
|
|
protected Field getField(Object paramObject, String paramString)
|
{
|
for (Class localClass = paramObject.getClass(); localClass != null; localClass = localClass.getSuperclass())
|
try
|
{
|
Field localField = localClass.getDeclaredField(paramString);
|
if (localField != null)
|
return localField;
|
}
|
catch (Exception localException)
|
{
|
}
|
return null;
|
}
|
|
protected Method getAccessor(Object paramObject, Field paramField, boolean paramBoolean)
|
{
|
String str = paramField.getName();
|
str = str.substring(0, 1).toUpperCase() + str.substring(1);
|
if (!(paramBoolean))
|
str = "set" + str;
|
else if (Boolean.TYPE.isAssignableFrom(paramField.getType()))
|
str = "is" + str;
|
else
|
str = "get" + str;
|
try
|
{
|
if (paramBoolean)
|
return getMethod(paramObject, str, null);
|
return getMethod(paramObject, str, new Class[] { paramField.getType() });
|
}
|
catch (Exception localException)
|
{
|
}
|
return null;
|
}
|
|
protected Method getMethod(Object paramObject, String paramString, Class[] paramArrayOfClass)
|
{
|
for (Class localClass = paramObject.getClass(); localClass != null; localClass = localClass.getSuperclass())
|
try
|
{
|
Method localMethod = localClass.getDeclaredMethod(paramString, paramArrayOfClass);
|
if (localMethod != null)
|
return localMethod;
|
}
|
catch (Exception localException)
|
{
|
}
|
return null;
|
}
|
|
protected Object getFieldValue(Object paramObject, String paramString)
|
{
|
Object localObject = null;
|
if ((paramObject != null) && (paramString != null))
|
{
|
Field localField = getField(paramObject, paramString);
|
try
|
{
|
if (localField != null)
|
localObject = localField.get(paramObject);
|
}
|
catch (IllegalAccessException localIllegalAccessException)
|
{
|
if (localField != null)
|
try
|
{
|
Method localMethod = getAccessor(paramObject, localField, true);
|
localObject = localMethod.invoke(paramObject, (Object[])null);
|
}
|
catch (Exception localException2)
|
{
|
}
|
}
|
catch (Exception localException1)
|
{
|
}
|
}
|
return localObject;
|
}
|
|
protected void setFieldValue(Object paramObject1, String paramString, Object paramObject2)
|
{
|
Field localField = null;
|
try
|
{
|
localField = getField(paramObject1, paramString);
|
if (localField.getType() == Boolean.class)
|
paramObject2 = ((paramObject2.equals("1")) || (String.valueOf(paramObject2).equalsIgnoreCase("true"))) ? Boolean.TRUE : Boolean.FALSE;
|
localField.set(paramObject1, paramObject2);
|
}
|
catch (IllegalAccessException localIllegalAccessException)
|
{
|
if (localField != null)
|
try
|
{
|
Method localMethod = getAccessor(paramObject1, localField, false);
|
Class localClass = localMethod.getParameterTypes()[0];
|
paramObject2 = convertValueFromXml(localClass, paramObject2);
|
if ((localClass.isArray()) && (paramObject2 instanceof Collection))
|
{
|
Collection localCollection = (Collection)paramObject2;
|
paramObject2 = localCollection.toArray((Object[])(Object[])Array.newInstance(localClass.getComponentType(), localCollection.size()));
|
}
|
localMethod.invoke(paramObject1, new Object[] { paramObject2 });
|
}
|
catch (Exception localException2)
|
{
|
System.err.println("setFieldValue: " + localException2 + " on " + paramObject1.getClass().getSimpleName() + "." + paramString + " (" + localField.getType().getSimpleName() + ") = " + paramObject2 + " (" + paramObject2.getClass().getSimpleName() + ")");
|
}
|
}
|
catch (Exception localException1)
|
{
|
}
|
}
|
|
public Object beforeEncode(mxCodec parammxCodec, Object paramObject, Node paramNode)
|
{
|
return paramObject;
|
}
|
|
public Node afterEncode(mxCodec parammxCodec, Object paramObject, Node paramNode)
|
{
|
return paramNode;
|
}
|
|
public Object decode(mxCodec parammxCodec, Node paramNode)
|
{
|
return decode(parammxCodec, paramNode, null);
|
}
|
|
public Object decode(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
Object localObject = null;
|
if (paramNode instanceof Element)
|
{
|
String str = ((Element)paramNode).getAttribute("id");
|
localObject = parammxCodec.objects.get(str);
|
if (localObject == null)
|
{
|
localObject = paramObject;
|
if (localObject == null)
|
localObject = cloneTemplate(paramNode);
|
if ((str != null) && (str.length() > 0))
|
parammxCodec.putObject(str, localObject);
|
}
|
paramNode = beforeDecode(parammxCodec, paramNode, localObject);
|
decodeNode(parammxCodec, paramNode, localObject);
|
localObject = afterDecode(parammxCodec, paramNode, localObject);
|
}
|
return localObject;
|
}
|
|
protected void decodeNode(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
if (paramNode == null)
|
return;
|
decodeAttributes(parammxCodec, paramNode, paramObject);
|
decodeChildren(parammxCodec, paramNode, paramObject);
|
}
|
|
protected void decodeAttributes(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
NamedNodeMap localNamedNodeMap = paramNode.getAttributes();
|
if (localNamedNodeMap == null)
|
return;
|
for (int i = 0; i < localNamedNodeMap.getLength(); ++i)
|
{
|
Node localNode = localNamedNodeMap.item(i);
|
decodeAttribute(parammxCodec, localNode, paramObject);
|
}
|
}
|
|
protected void decodeAttribute(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
String str1 = paramNode.getNodeName();
|
if ((str1.equalsIgnoreCase("as")) || (str1.equalsIgnoreCase("id")))
|
return;
|
Object localObject1 = paramNode.getNodeValue();
|
String str2 = getFieldName(str1);
|
if (isReference(paramObject, str2, localObject1, false))
|
{
|
Object localObject2 = parammxCodec.getObject(String.valueOf(localObject1));
|
if (localObject2 == null)
|
{
|
System.err.println("mxObjectCodec.decode: No object for " + getName() + "." + str2 + "=" + localObject1);
|
return;
|
}
|
localObject1 = localObject2;
|
}
|
if (isExcluded(paramObject, str2, localObject1, false))
|
return;
|
setFieldValue(paramObject, str2, localObject1);
|
}
|
|
protected void decodeChildren(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
for (Node localNode = paramNode.getFirstChild(); localNode != null; localNode = localNode.getNextSibling())
|
{
|
if ((localNode.getNodeType() != 1) || (processInclude(parammxCodec, localNode, paramObject)))
|
continue;
|
decodeChild(parammxCodec, localNode, paramObject);
|
}
|
}
|
|
protected void decodeChild(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
String str = getFieldName(((Element)paramNode).getAttribute("as"));
|
if ((str != null) && (isExcluded(paramObject, str, paramNode, false)))
|
return;
|
Object localObject1 = getFieldTemplate(paramObject, str, paramNode);
|
Object localObject2 = null;
|
if (paramNode.getNodeName().equals("add"))
|
{
|
localObject2 = ((Element)paramNode).getAttribute("value");
|
if (localObject2 == null)
|
localObject2 = paramNode.getTextContent();
|
}
|
else
|
{
|
localObject2 = parammxCodec.decode(paramNode, localObject1);
|
}
|
addObjectValue(paramObject, str, localObject2, localObject1);
|
}
|
|
protected Object getFieldTemplate(Object paramObject, String paramString, Node paramNode)
|
{
|
Object localObject = getFieldValue(paramObject, paramString);
|
if ((localObject != null) && (localObject.getClass().isArray()))
|
localObject = null;
|
else if (localObject instanceof Collection)
|
((Collection)localObject).clear();
|
return localObject;
|
}
|
|
protected void addObjectValue(Object paramObject1, String paramString, Object paramObject2, Object paramObject3)
|
{
|
if ((paramObject2 == null) || (paramObject2.equals(paramObject3)))
|
return;
|
if ((paramString != null) && (paramObject1 instanceof Map))
|
{
|
((Map)paramObject1).put(paramString, paramObject2);
|
}
|
else if ((paramString != null) && (paramString.length() > 0))
|
{
|
setFieldValue(paramObject1, paramString, paramObject2);
|
}
|
else
|
{
|
if (!(paramObject1 instanceof Collection))
|
return;
|
((Collection)paramObject1).add(paramObject2);
|
}
|
}
|
|
public boolean processInclude(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
if ((paramNode.getNodeType() == 1) && (paramNode.getNodeName().equalsIgnoreCase("include")))
|
{
|
String str = ((Element)paramNode).getAttribute("name");
|
if (str != null)
|
try
|
{
|
Element localElement = mxUtils.loadDocument(mxObjectCodec.class.getResource(str).toString()).getDocumentElement();
|
if (localElement != null)
|
parammxCodec.decode(localElement, paramObject);
|
}
|
catch (Exception localException)
|
{
|
System.err.println("Cannot process include: " + str);
|
}
|
return true;
|
}
|
return false;
|
}
|
|
public Node beforeDecode(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
return paramNode;
|
}
|
|
public Object afterDecode(mxCodec parammxCodec, Node paramNode, Object paramObject)
|
{
|
return paramObject;
|
}
|
}
|
|
/* Location: C:\Users\platform-001\Desktop\新建文件夹 (2)\jgraphx.jar
|
* Qualified Name: com.mxgraph.io.mxObjectCodec
|
* JD-Core Version: 0.5.3
|
*/
|
