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
 */