private static void _DeserializationHandler(out Vector2 output, SerializedObjectNode serializedNode, Type baseType)
{
string[] parts = serializedNode.Value.Split(' ');
output.x = float.Parse(parts[0]);
output.y = float.Parse(parts[1]);
}
/// <summary>
/// Creates a serialized object from an XmlNode that is the child of a parent node
/// </summary>
/// <param name="node">The xml node that this serialized object is wrapping</param>
/// <param name="parentNode">The parent node that we are a part of</param>
protected SerializedObjectNode(XmlNode node, SerializedObjectNode parentNode)
{
m_xmlNode = node;
m_parentNode = parentNode;
if (m_xmlNode.Attributes != null)
{
XmlAttribute versionAttribute = m_xmlNode.Attributes["version"];
if (versionAttribute != null)
{
string fullVersionString = versionAttribute.Value;
while (!string.IsNullOrEmpty(fullVersionString))
{
int versionNameDelimiterIndex = fullVersionString.IndexOf(',');
string versionName = versionNameDelimiterIndex < 0 ? fullVersionString : fullVersionString.Substring(0, versionNameDelimiterIndex);
if (versionNameDelimiterIndex > -1)
fullVersionString = fullVersionString.Substring(versionNameDelimiterIndex + 1);
else
fullVersionString = null;
SerializedVersionInfo newVersionInfo = SerializedVersionInfo.Parse(versionName);
m_versionInfo.AddFirst(newVersionInfo);
}
}
}
foreach (XmlNode childNode in m_xmlNode.ChildNodes)
{
SerializedObjectNode newChildNode = new SerializedObjectNode(childNode, this);
m_children.Add(childNode.Name, newChildNode);
}
}
/// <summary>
/// Creates a new serialized object to serialize into.
/// </summary>
public SerializedObject()
{
XmlDocument document = new XmlDocument();
m_rootXmlNode = document.CreateElement("root");
document.AppendChild(m_rootXmlNode);
m_rootNode = new SerializedObjectNode(m_rootXmlNode);
}
/// <summary>
/// Creates a serialized object.
/// </summary>
/// <param name="stream">The stream to read the serialized object data from.</param>
public SerializedObject(Stream stream)
{
XmlReader reader = XmlReader.Create(stream);
XmlDocument document = new XmlDocument();
document.Load(reader);
m_rootXmlNode = document["root"];
m_rootNode = new SerializedObjectNode(m_rootXmlNode);
}
private static void _DeserializationHandler(out object output, SerializedObjectNode serializedNode, Type baseType)
{
if (serializedNode.Value == "NULL")
{
output = null;
return;
}
Type type = baseType;
output = Activator.CreateInstance(type);
//apply version updating
Type expectedType = type;
foreach (SerializedVersionInfo serializedVersionInfo in serializedNode.IterateVersionInfo())
{
Type savedType = TypeHelper.GetType(serializedVersionInfo.TypeName);
if (savedType == expectedType || savedType == null)
{
SerializedVersionInfo currentVersionInfo = SerializedVersionInfo.Create(expectedType);
for (int i = serializedVersionInfo.VersionNumber + 1; i <= currentVersionInfo.VersionNumber; i++)
{
MethodInfo upgradeMethodInfo = expectedType.GetMethod(string.Format("_UpgradeToVersion{0}", i),
BindingFlags.Static | BindingFlags.NonPublic, null, new[] {typeof(SerializedObjectNode)}, null);
if (upgradeMethodInfo != null)
{
foreach (SerializedObjectNode childNode in serializedNode.IterateChildren())
{
upgradeMethodInfo.Invoke(null, new object[] {childNode});
}
}
}
}
if (expectedType != null)
expectedType = expectedType.BaseType;
}
foreach (SerializedObjectNode childNode in serializedNode.IterateChildren())
{
FieldInfo field = TypeHelper.GetField(type, childNode.Name);
if (field == null)
continue;
Type fieldType = field.FieldType;
object fieldObject;
_InvokeDeserializerHandler(out fieldObject, childNode, fieldType);
field.SetValue(output, fieldObject);
}
}
/// <summary>
/// Creates a serialized object.
/// </summary>
/// <param name="document">The XmlDocument to read from.</param>
public SerializedObject(XmlDocument document)
{
m_rootXmlNode = document["root"];
if (m_rootXmlNode == null)
{
m_rootXmlNode = document.CreateElement("root");
document.AppendChild(m_rootXmlNode);
}
m_rootNode = new SerializedObjectNode(m_rootXmlNode);
}
/// <summary>
/// Creates a serialized object.
/// </summary>
/// <param name="file">The file to read the serialized object from.</param>
public SerializedObject(string file)
{
using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read))
{
XmlReader reader = XmlReader.Create(stream);
XmlDocument document = new XmlDocument();
document.Load(reader);
m_rootXmlNode = document["root"];
m_rootNode = new SerializedObjectNode(m_rootXmlNode);
}
}
private static void _SerializationHandler(IList target, SerializedObjectNode targetNode)
{
int count = target.Count;
for (int i = 0; i < count; i++)
{
SerializedObjectNode node = targetNode.CreateChild("entry" + i);
object value = target[i];
_InvokeSerializerHandler(value, node);
}
}
private static void _SerializationHandler(Array target, SerializedObjectNode targetNode)
{
Assert.AreEqual(1, target.Length);
int count = target.Length;
for (int i = 0; i < count; i++)
{
SerializedObjectNode node = targetNode.CreateChild("entry" + i);
object value = target.GetValue(i);
_InvokeSerializerHandler(value, node);
}
}
private static void _SerializationHandler(IDictionary target, SerializedObjectNode targetNode)
{
int i = 0;
foreach (object key in target.Keys)
{
SerializedObjectNode node = targetNode.CreateChild("entry" + i);
SerializedObjectNode keyNode = node.CreateChild("key");
SerializedObjectNode valueNode = node.CreateChild("value");
_InvokeSerializerHandler(key, keyNode);
_InvokeSerializerHandler(target[key], valueNode);
i++;
}
}
private static void _DeserializationHandler(out IList output, SerializedObjectNode serializedNode, Type baseType)
{
Type elementType = baseType.GetElementType();
output = Activator.CreateInstance(baseType) as IList;
Assert.IsNotNull(output);
foreach (SerializedObjectNode child in serializedNode.IterateChildren())
{
object element = FormatterServices.GetUninitializedObject(elementType);
_InvokeDeserializerHandler(out element, child, elementType);
output.Add(element);
}
}
private static void _SerializationHandler(object target, SerializedObjectNode targetNode)
{
Type targetType = target.GetType();
FieldInfo[] fields = TypeHelper.GetFields(targetType, typeof (SerializeField), true);
foreach (FieldInfo fieldInfo in fields)
{
SerializedObjectNode fieldNode = targetNode.CreateChild(fieldInfo.Name);
object fieldValue = fieldInfo.GetValue(target);
_InvokeSerializerHandler(fieldValue, fieldNode);
}
targetNode.SetVersionInfo(targetType);
}
private static void _DeserializationHandler(out Array output, SerializedObjectNode serializedNode, Type baseType)
{
int length = serializedNode.GetChildCount();
Type elementType = baseType.GetElementType();
output = Array.CreateInstance(elementType, length);
int i = 0;
foreach (SerializedObjectNode serializedObjectNode in serializedNode.IterateChildren())
{
object element;
_InvokeDeserializerHandler(out element, serializedObjectNode, elementType);
output.SetValue(element, i);
i++;
}
}
private static void _DeserializationHandler(out string output, SerializedObjectNode serializedNode, Type baseType)
{
output = serializedNode.Value;
}
private static void _UpgradeToVersion1(SerializedObjectNode field)
{
if(field.Name == "a")
field.Rename("d");
}
private static void _SerializationHandler(Quaternion target, SerializedObjectNode targetNode)
{
targetNode.Value = string.Format("{0} {1} {2} {3}", target.x, target.y, target.z, target.w);
}
/// <summary>
/// Creates a child node under this node.
/// </summary>
/// <param name="name">The name of the child node to create.</param>
/// <returns>The new child node.</returns>
public SerializedObjectNode CreateChild(string name)
{
XmlNode xmlChildNode = m_xmlNode.OwnerDocument.CreateElement(name);
m_xmlNode.AppendChild(xmlChildNode);
SerializedObjectNode childNode = new SerializedObjectNode(xmlChildNode, this);
m_children.Add(name, childNode);
return childNode;
}
private static void _DeserializationHandler(out char output, SerializedObjectNode serializedNode, Type baseType)
{
Assert.AreEqual(1, serializedNode.Value.Length);
output = serializedNode.Value[0];
}
private static void _SerializationHandler(Vector3 target, SerializedObjectNode targetNode)
{
targetNode.Value = string.Format("{0} {1} {2}", target.x, target.y, target.z);
}
private static void _DeserializationHandler(out float output, SerializedObjectNode serializedNode, Type baseType)
{
output = float.Parse(serializedNode.Value);
}
private static void _DeserializationHandler(out TimeSpan output, SerializedObjectNode serializedNode, Type baseType)
{
output = TimeSpan.Parse(serializedNode.Value);
}
private static void _SerializationHandler(TimeSpan target, SerializedObjectNode targetNode)
{
targetNode.Value = target.ToString();
}
private static void _SerializationHandler(string target, SerializedObjectNode targetNode)
{
targetNode.Value = target;
}
private static void _DeserializationHandler(out IDictionary output, SerializedObjectNode serializedNode, Type baseType)
{
Type[] genericArgumenTypes = baseType.GetGenericArguments();
output = Activator.CreateInstance(baseType) as IDictionary;
Assert.IsNotNull(output);
if (genericArgumenTypes.Length == 0)
genericArgumenTypes = new[] { typeof(object), typeof(object) };
Type keyType = genericArgumenTypes[0];
Type valueType = genericArgumenTypes[1];
foreach (SerializedObjectNode serializedObjectNode in serializedNode.IterateChildren())
{
SerializedObjectNode keyNode = serializedObjectNode["key"];
SerializedObjectNode valueNode = serializedObjectNode["value"];
object key;
object value;
_InvokeDeserializerHandler(out key, keyNode, keyType);
_InvokeDeserializerHandler(out value, valueNode, valueType);
output.Add(key, value);
}
}
private static void _SerializationHandler(DateTime target, SerializedObjectNode targetNode)
{
targetNode.Value = target.ToString(CultureInfo.InvariantCulture);
}
