public static void DeserializeFromData <T>(ref T instance, PrimitiveData data, Type peak)
{
var obj = instance as object;
ReferenceDeserializer references = new ReferenceDeserializer();
deserializeFromData(ref obj, data, peak, references);
}
private static void deserializeDataObject(ref object instance, PrimitiveData data, Type peak, ReferenceDeserializer references)
{
var objectDictionary = data.ToDataObject();
if (instance.GetType().HasAttribute <ReferenceableAttribute>())
{
references.AddReferenceable(data.ReferenceID, instance);
}
foreach (var field in instance.GetType().GetAllFields(peak, bindingFlags))
{
PrimitiveData subData;
if (objectDictionary.TryGetValue(field.Name, out subData))
{
if (field.HasAttribute <ReferenceAttribute>())
{
references.Push(instance, field, subData.ReferenceID);
}
else
{
field.SetValue(instance, deserializeFromData(field.FieldType, subData, typeof(object), references));
}
}
}
}
private static object deserializeDataArray(Type type, PrimitiveData data, ReferenceDeserializer references)
{
var instance = Activator.CreateInstance(type) as ICollection;
deserializeDataArray(ref instance, data, references);
return(instance);
}
public static bool ReadInternalFile(this MyZipArchive.Reader reader, string internalFileName, out PrimitiveData data)
{
byte[] raw;
if (reader.ReadInternalFile(internalFileName, out raw))
{
data = MyByteConverter.ToObject <PrimitiveData>(raw);
return(true);
}
data = new PrimitiveData();
return(false);
}
private static object deserializeDataObject(Type type, PrimitiveData data, Type peak, ReferenceDeserializer references)
{
var instance = Activator.CreateInstance(data.OriginalType);
deserializeDataObject(ref instance, data, peak, references);
return(instance);
//var objectDictionary = data.ToDataObject();
//foreach (var field in type.GetAllFields(peak, bindingFlags))
//{
// PrimitiveData subData;
// if (objectDictionary.TryGetValue(field.Name, out subData))
// field.SetValue(instance, deserializeFromData(field.FieldType, subData, typeof(object)));
//}
//return instance;
}
private static void deserializeDataArray(ref ICollection instance, PrimitiveData data, ReferenceDeserializer references)
{
var array = data.ToList();
//var elementType = GetElementType(instance.GetType());
var elementType = instance.GetType().GetGenericArguments()[0];
//var collection = makeCollection(elementType);
var collection = instance;
//Result.GetType().GetMethod("Add").Invoke(Result, new[] { objTemp });
//var list = typeof(ICollection<>).MakeGenericType(elementType);
foreach (var element in array)
{
var obj = deserializeFromData(elementType, element, typeof(object), references);
collection.GetType().GetMethod("Add").Invoke(collection, new[] { obj });
}
}
private static void deserializeFromData(ref object instance, PrimitiveData data, Type peak, ReferenceDeserializer references)
{
if (data.Type == PrimitiveDataType.Null || data.Type == PrimitiveDataType.Invaild)
{
throw new InvalidOperationException("Data was null or invalid.");
}
if (data.Type == PrimitiveDataType.Object)
{
deserializeDataObject(ref instance, data, peak, references);
}
else if (data.Type == PrimitiveDataType.Array)
{
var collection = instance as ICollection;
deserializeDataArray(ref collection, data, references);
}
else
{
data.ToObject(instance.GetType());
}
}
private static object deserializeFromData(Type type, PrimitiveData data, Type peak, ReferenceDeserializer references)
{
if (data.Type == PrimitiveDataType.Null || data.Type == PrimitiveDataType.Invaild)
{
throw new InvalidOperationException("Data was null or invalid.");
}
//var peakABoo = PrimitiveData.GetType()
if (data.Type == PrimitiveDataType.Object)
{
return(deserializeDataObject(type, data, peak, references));
}
else if (data.Type == PrimitiveDataType.Array)
{
return(deserializeDataArray(type, data, references));
}
else
{
return(data.ToObject(type));
}
}
private static PrimitiveData serializeIntoData(object obj, Type peak, ReferenceSerializer references)
{
var type = obj.GetType();
//if (obj == null)
// yield return new PrimitiveData();
if (type.IsSerializable && PrimitiveData.IsAcceptable(obj))
{
return(new PrimitiveData(obj));
}
if (obj is IEnumerable || obj is ICollection)
{
return(serializeArray(obj, references));
}
return(serializeObject(obj, peak, references));
//Dictionary<string, PrimitiveData> objectDictionary = new Dictionary<string, PrimitiveData>();
//foreach (var field in type.GetAllFields(peak, bindingFlags))
//{
// var subObj = field.GetValue(obj);
// if (subObj != null && (subObj.GetType().IsValueType || subObj is string || subObj.GetType().HasParameterlessConstructor()))
// {
// var data = serializeIntoData(subObj, typeof(object));
// if (data.Type == PrimitiveDataType.Invaild)
// throw new InvalidOperationException(string.Format("Object ({0}) could not be serialized.", subObj.GetType().Name));
// objectDictionary.Add(field.Name, data);
// }
//}
//return new PrimitiveData(objectDictionary);
}
public static void WriteFileToArchive(this MyZipArchive.Writer writer, string fileName, PrimitiveData data)
{
writer.WriteFileToArchive(fileName, MyByteConverter.ToByteArray(data));
}
public static object DeserializeFromData(Type type, PrimitiveData data, Type peak)
{
ReferenceDeserializer references = new ReferenceDeserializer();
return(deserializeFromData(type, data, peak, references));
}
public static void DeserializeFromData <T>(ref T instance, PrimitiveData data)
{
DeserializeFromData(ref instance, data, typeof(object));
}
public static T DeserializeFromData <T>(PrimitiveData data, Type peak)
{
ReferenceDeserializer references = new ReferenceDeserializer();
return((T)deserializeFromData(typeof(T), data, peak, references));
}
public static T DeserializeFromData <T>(PrimitiveData data)
{
return(DeserializeFromData <T>(data, typeof(object)));
}
