public static bool TypeFound(XMLSerializerParams parameters, XElement xElement, XAttribute typeAttribute, SerializableTypeCache type, string filename, List <SerializerError> errors)
{
if (ReferenceEquals(type, null))
{
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, (xElement as IXmlLineInfo).LineNumber, "Element type " + typeAttribute.Value + " unknown!"));
return(false);
}
return(true);
}
public static bool NodeIsElement(XMLSerializerParams parameters, XNode xNode, string filename, List <SerializerError> errors)
{
if (!(xNode is XElement)) // Malformed XML
{
string msg = string.Format("Unable to cast node to element for {0}!", xNode);
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, (xNode as IXmlLineInfo).LineNumber, msg));
return(false);
}
return(true);
}
public static bool ContainerElementName(XMLSerializerParams parameters, XElement xElement, string filename, List <SerializerError> errors)
{
if (!string.Equals(xElement.Name.LocalName, parameters.rootElementName))
{
string msg = string.Format("Element name '{0}' is incorrect / not supported, must be '{1}'!", xElement.Name, parameters.rootElementName);
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, (xElement as IXmlLineInfo).LineNumber, msg));
return(false);
}
return(true);
}
public static bool TypeCheck(XMLSerializerParams parameters, IXmlLineInfo debug, string fieldName, object value, Type expectedType, string filename, List <SerializerError> errors)
{
if (!ReferenceEquals(value, null) && !expectedType.IsAssignableFrom(value.GetType()))
{
string msg = string.Format("Fatal error deserializing field {0} - tried applying field data but types mismatched! Stored type: {1} - Expected type: {2}!", fieldName, value.GetType(), expectedType);
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, ReferenceEquals(debug, null) ? -1 : debug.LineNumber, msg));
return(false);
}
return(true);
}
protected override Vector2 _Deserialize(string value, XMLSerializerParams parameters)
{
string[] parts = value.Split(',');
if (parts.Length < 2)
{
throw new FormatException("Malformed vector2 data " + value + " - Format: (x,y - . as decimal delimiter)");
}
return(new Vector2(float.Parse(parts[0], CultureInfo.InvariantCulture), float.Parse(parts[1], CultureInfo.InvariantCulture)));
}
public static bool DataFieldSerializerValid(XMLSerializerParams parameters, XElement xElement, SerializableTypeCache typeCache, string typeName, string fieldName, string filename, List <SerializerError> errors)
{
if (ReferenceEquals(typeCache, null))
{
// TODO: Explanation - why unserializable!?
string msg = string.Format("Field '{0}' with unserializeable type {1}!", fieldName, typeName);
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, (xElement as IXmlLineInfo).LineNumber, msg));
return(false);
}
return(true);
}
public static bool FieldKnown(XMLSerializerParams parameters, IXmlLineInfo debug, SerializableTypeCache type, string field, string filename, List <SerializerError> errors)
{
if (!type.HasField(field))
{
// TODO: Line number
string msg = string.Format("Unknown field {0}!", field);
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, ReferenceEquals(debug, null) ? -1 : debug.LineNumber, msg));
return(false);
}
return(true);
}
public static bool SerializerWasFound(XMLSerializerParams parameters, IXmlLineInfo debug, IXMLDataSerializer serializer, string field, Type declaringType, Type fieldType, string filename, List <SerializerError> errors)
{
if (ReferenceEquals(serializer, null))
{
// TODO: Line number
string msg = string.Format("Serializer for field {0} on type {1} (Field type: {2}) could not be found!", field, declaringType, fieldType);
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, ReferenceEquals(debug, null) ? -1 : debug.LineNumber, msg));
return(false);
}
return(true);
}
protected override Type _Deserialize(string value, XMLSerializerParams parameters)
{
// Create std namespace name string by prepending std namespace to value
bool doStdNamespaceCheck = !string.IsNullOrWhiteSpace(parameters.standardNamespace);
string stdNamespacePrepended = doStdNamespaceCheck ? parameters.standardNamespace + "." + value : null;
// Look for type
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
var t = asm.GetType(value, false, false);
if (doStdNamespaceCheck && ReferenceEquals(t, null))
{
t = asm.GetType(stdNamespacePrepended, false, false);
}
if (!ReferenceEquals(t, null))
{
return(t);
}
}
return(null);
}
/// <summary>
/// <see cref="SerializedData.LoadFields(List{SerializerError}, PrototypeParserState)"/>
/// </summary>
/// <param name="errors"></param>
/// <param name="filename">The filename from where data will be parsed. Only used for error reporting.</param>
public void ParseAndLoadData(string filename, List <SerializerError> errors, XMLSerializerParams parameters)
{
var elementNodes = xElement.Nodes().ToList();
var collection = GetCollectionInstance(this.collectionType, elementNodes.Count);
Type elementType = GetElementType(this.collectionType);
var elementTypeCache = SerializerCache.GetSerializableTypeCacheFor(elementType);
string elementTypeName = elementType.Name;
foreach (var node in elementNodes)
{
var xElementNode = node as XElement;
if (ReferenceEquals(xElementNode, null)) // Malformed XML
{
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, (node as IXmlLineInfo).LineNumber, "Unable to cast node to element for " + node + "! Skipping element!"));
continue;
}
IXMLDataSerializer serializer = SerializerCache.GetBestSerializerFor(elementType);
if (!ReferenceEquals(serializer, null))
{
try
{
if (!SerializerValidation.SerializerWasFound(parameters, null, serializer, "Collection", null, elementType, "SERIALIZE", errors))
{
continue;
}
this.elements.Add(serializer.Deserialize(elementType, xElementNode, parameters));
}
catch (Exception ex)
{
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, "SERIALIZE", -1, "Serializer threw exception on collection of type " + elementType + ":\n\n" + ex.ToString() + "\n\nSkipping element!"));
}
}
else if (typeof(ISerializableRoot).IsAssignableFrom(elementType))
{
// object ref
this.elements.Add(new SerializedRootObjectReference()
{
identifier = xElementNode.Value
});
}
else
{
// Determine type
var serializableTypeCache = elementTypeCache;
string typeName = elementTypeName;
// Try to read class attrib
var classAttrib = xElementNode.Attribute(XMLSerializer.AttributeType);
if (!ReferenceEquals(classAttrib, null))
{
serializableTypeCache = SerializerCache.GetSerializableTypeCacheFor(classAttrib.Value, parameters.standardNamespace);
typeName = classAttrib.Value;
}
// Validity checks
// Field not serializable?
if (ReferenceEquals(serializableTypeCache, null))
{
// TODO: Line number, better reporting as to why this type is unserializable!
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, filename, -1, "Collection element with unknown type " + typeName + " unserializable! Skipping field!"));
continue;
}
// Add element
this.elements.Add(new SerializedData(serializableTypeCache, xElementNode));
}
}
foreach (var element in this.elements)
{
var sElement = element as SerializedData;
if (!ReferenceEquals(sElement, null))
{
sElement.LoadFieldsFromXML(filename, errors, parameters);
}
}
}
protected override string Serialize(short value, XMLSerializerParams parameters)
{
return(value.ToString());
}
protected override string Serialize(double value, XMLSerializerParams parameters)
{
return(value.ToString(CultureInfo.InvariantCulture));
}
protected override uint _Deserialize(string value, XMLSerializerParams parameters)
{
return(uint.Parse(value));
}
protected abstract T _Deserialize(string value, XMLSerializerParams parameters);
protected override sbyte _Deserialize(string value, XMLSerializerParams parameters)
{
return(sbyte.Parse(value));
}
public object Deserialize(Type type, XElement value, XMLSerializerParams parameters)
{
return(Enum.Parse(type, value.Value as string));
}
public void Serialize(object obj, XElement target, XMLSerializerParams parameters)
{
target.Value = obj.ToString();
}
protected override bool _Deserialize(string value, XMLSerializerParams parameters)
{
return(bool.Parse(value));
}
protected override string Serialize(Type value, XMLSerializerParams parameters)
{
return(value.Name);
}
protected override string Serialize(Vector2 value, XMLSerializerParams parameters)
{
return(string.Format("{0},{1}", value.x.ToString().Replace(',', '.'), value.y.ToString().Replace(',', '.')));
}
protected abstract string Serialize(T value, XMLSerializerParams parameters);
public object Deserialize(Type type, XElement value, XMLSerializerParams parameters)
{
return(_Deserialize(value.Value, parameters));
}
protected override string _Deserialize(string value, XMLSerializerParams parameters)
{
return(value);
}
protected override string Serialize(Color value, XMLSerializerParams parameters)
{
return(string.Format("{0},{1},{2},{3}", value.r.ToString().Replace(',', '.'), value.g.ToString().Replace(',', '.'), value.b.ToString().Replace(',', '.'), value.a.ToString().Replace(',', '.')));
}
protected override double _Deserialize(string value, XMLSerializerParams parameters)
{
return(double.Parse(value, CultureInfo.InvariantCulture));
}
public void Serialize(object obj, XElement target, XMLSerializerParams parameters)
{
target.Value = Serialize((T)obj, parameters);
}
/// <summary>
/// Serializes the collection obj to <see cref="xElement"/>.
/// </summary>
/// <param name="targetElement">The element to write the loaded data to.</param>
/// <param name="obj">The collection to load and write to <see cref="xElement"/></param>
/// <param name="referenceables">Serializable object roots which will possibly be referenced by elements in obj.</param>
public void WriteFromObject(object collection, XElement targetElement, List <SerializerError> errors, XMLSerializerParams parameters)
{
Type elementType = GetElementType(this.collectionType);
var elementTypeCache = SerializerCache.GetSerializableTypeCacheFor(elementType);
string elementTypeName = elementType.Name;
foreach (var obj in (collection as IEnumerable))
{
XElement _targetElement = new XElement("li");
targetElement.Add(_targetElement);
if (obj == null)
{
_targetElement.Add(XMLSerializer.TokenNull);
continue;
}
var objType = obj.GetType();
IXMLDataSerializer serializer = SerializerCache.GetBestSerializerFor(objType);
if (!ReferenceEquals(serializer, null))
{
try
{
if (!SerializerValidation.SerializerWasFound(parameters, null, serializer, "Collection", null, objType, "SERIALIZE", errors))
{
continue;
}
serializer.Serialize(obj, _targetElement, parameters);
}
catch (Exception ex)
{
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, "SERIALIZE", -1, "Serializer threw exception on collection of type " + objType + ":\n\n" + ex.ToString() + "\n\nSkipping field!"));
}
}
else if (typeof(ISerializableRoot).IsAssignableFrom(elementType))
{
// object ref
_targetElement.Value = (obj as ISerializableRoot).identifier;
}
else
{
// Determine type
var serializableTypeCache = elementTypeCache;
string typeName = elementTypeName;
// Write class attribute
_targetElement.SetAttributeValue(XMLSerializer.AttributeType, typeName);
// Validity checks
// Field not serializable?
if (ReferenceEquals(serializableTypeCache, null))
{
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, "SERIALIZER", -1, "Collection element with unknown type " + typeName + " unserializable! Skipping element!"));
continue;
}
// Add element
new SerializedData(serializableTypeCache, _targetElement).WriteFromObject(obj, errors, parameters);
}
}
}
protected override string Serialize(Quaternion value, XMLSerializerParams parameters)
{
return(string.Format("{0},{1},{2},{3}", value.x.ToString().Replace(',', '.'), value.y.ToString().Replace(',', '.'), value.z.ToString().Replace(',', '.'), value.w.ToString().Replace(',', '.')));
}
public void ResolveReferenceFieldsAndSubData(string filename, List <ISerializableRoot> objects, List <SerializerError> errors, XMLSerializerParams parameters)
{
for (int i = 0; i < this.elements.Count; i++)
{
// Finalize, create and apply
var element = this.elements[i];
var sElement = element as SerializedData;
var protoRef = element as SerializedRootObjectReference;
if (!ReferenceEquals(sElement, null))
{
sElement.ResolveReferenceFields(filename, objects, errors, parameters);
var value = sElement.targetType.Create();
sElement.ApplyTo(filename, value, errors, parameters);
this.elements[i] = value;
}
else if (!ReferenceEquals(protoRef, null))
{
this.elements[i] = protoRef.Resolve(objects);
}
}
}
public void WriteFromObject(object obj, List <SerializerError> errors, XMLSerializerParams parameters)
{
targetType.GetAllFields(_fields);
foreach (var fieldData in _fields)
{
if (!fieldData.isSerialized)
{
continue;
}
string fieldName = fieldData.fieldInfo.Name;
XElement targetElement = new XElement(fieldName);
xElement.Add(targetElement);
var fieldObj = fieldData.fieldInfo.GetValue(obj);
if (fieldObj == null) // Null special case
{
if (!fieldData.fieldInfo.GetCustomAttributes(true).Any((attrib) => attrib is AlwaysSerializedAttribute))
{
return;
}
targetElement.Value = XMLSerializer.TokenNull;
continue;
}
var fieldObjType = SerializerCache.GetSerializableTypeCacheFor(fieldObj.GetType());
bool isCollection = SerializedCollectionData.IsCollection(fieldData.fieldInfo.FieldType);
IXMLDataSerializer serializer = SerializerCache.GetBestSerializerFor(fieldData.fieldInfo.FieldType);
if (!ReferenceEquals(serializer, null))
{
try
{
if (!SerializerValidation.SerializerWasFound(parameters, targetElement, serializer, fieldName, fieldObjType == null ? null : fieldObjType.type, fieldObjType == null ? null : fieldObjType.type, "SERIALIZE", errors))
{
continue;
}
serializer.Serialize(fieldObj, targetElement, parameters);
}
catch (Exception ex)
{
errors.Add(new SerializerError(SerializerErrorSeverity.ERROR, "SERIALIZE", -1, "Serializer threw exception on field " + fieldName + " on type " + fieldObjType.type + ":\n\n" + ex.ToString() + "\n\nSkipping field!"));
}
}
else if (isCollection)
{
var col = new SerializedCollectionData(fieldData.fieldInfo.FieldType, targetElement);
col.WriteFromObject(fieldObj, targetElement, errors, parameters);
}
else
{
// root reference?
if (fieldData.isSerializableRoot)
{
targetElement.Value = (fieldObj as ISerializableRoot).identifier;
}
else
{
// Determine which type to serialize
string typeName = fieldObjType.type.Name;
// Write class attribute
if (!ReferenceEquals(fieldData.fieldInfo.FieldType, fieldObjType.type))
{
targetElement.SetAttributeValue(XMLSerializer.AttributeType, typeName);
}
// Field not serializable?
if (!SerializerValidation.DataFieldSerializerValid(parameters, targetElement, fieldObjType, typeName, fieldName, "SERIALIZE", errors))
{
continue;
}
// Write field
var d = new SerializedData(fieldObjType, targetElement);
d.WriteFromObject(fieldObj, errors, parameters);
}
}
}
}
