internal UnmarshallingContext(XStreamReader reader, ConverterLookup converterLookup, Aliases aliases, List <Assembly> assemblies)
{
this.reader = reader;
this.converterLookup = converterLookup;
this.aliases = aliases;
this.assemblies = assemblies;
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
int count = reader.NoOfChildren();
// Use the actual data type we are deserializing to rather than inferring from xml metadata
Type arrayType = context.currentTargetType;
string arrayTypeName = reader.GetAttribute(ARRAY_TYPE);
if (arrayTypeName != "")
{
arrayType = context.GetTypeFromOtherAssemblies(arrayTypeName);
}
if (arrayType.IsArray)
{
// Due to the way that the currentTargetType and the constructor works, we need to get the element type instead of the current type.
// This probably won't work well for arrays of arrays.
arrayType = arrayType.GetElementType();
}
Array result = Array.CreateInstance(arrayType, count);
if (count != 0)
{
reader.MoveDown();
for (int i = 0; i < count; i++)
{
result.SetValue(context.ConvertOriginal(), i);
reader.MoveNext();
}
reader.MoveUp();
}
return(result);
}
//Todo: duplicated!! refactor
private static SerializedValue ReadSerializedValue(XStreamReader xStreamReader)
{
var tagName = xStreamReader.GetNodeName();
string attributeValue = xStreamReader.GetAttribute(XsAttribute.classType);
string nullValue = xStreamReader.GetAttribute(XsAttribute.Null);
var classAtrribute = new XsAttribute(XsAttribute.classType, attributeValue);
var nullAtrribute = new XsAttribute(XsAttribute.Null, nullValue);
return new SerializedValue(tagName, classAtrribute, nullAtrribute);
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
IList result = (IList) DynamicInstanceBuilder.CreateInstance(Type.GetType(reader.GetAttribute(LIST_TYPE)));
int count = reader.NoOfChildren();
reader.MoveDown();
for (int i = 0; i < count; i++) {
result.Add(context.ConvertAnother());
reader.MoveNext();
}
reader.MoveUp();
return result;
}
public object UnMarshall(XStreamReader reader, UnmarshallingContext context, Type type)
{
var result = context.FindReferenceFromCurrentNode();
if (result != null) return result;
if (reader.GetAttribute(XsAttribute.Null) == true.ToString())
return null;
result = DynamicInstanceBuilder.CreateInstance(type);
context.StackObject(result);
UnmarshalAs(result, type, reader, context);
return result;
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
var folders = new Folders();
var count = reader.NoOfChildren();
reader.MoveDown();
for (var i = 0; i < count; i++) {
folders.Add((Folder) context.ConvertAnother());
reader.MoveNext();
}
reader.MoveUp();
return folders;
}
public object FromXml(XStreamReader reader, UnmarshallingContext context) {
int count = reader.NoOfChildren();
Array result = Array.CreateInstance(context.GetTypeFromOtherAssemblies(reader.GetAttribute(ARRAY_TYPE)), count);
if (count != 0) {
reader.MoveDown();
for (int i = 0; i < count; i++) {
result.SetValue(context.ConvertOriginal(), i);
reader.MoveNext();
}
reader.MoveUp();
}
return result;
}
public object UnMarshall(XStreamReader reader, UnmarshallingContext context, Type type)
{
IList result = (IList) DynamicInstanceBuilder.CreateInstance(Type.GetType(reader.GetAttribute(LIST_TYPE)));
int count = reader.NoOfChildren();
reader.MoveDown();
for (int i = 0; i < count; i++) {
object item = ReadItem(reader, context, result);
result.Add(item);
reader.MoveNext();
}
reader.MoveUp();
return result;
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
IList result = (IList)DynamicInstanceBuilder.CreateInstance(Type.GetType(reader.GetAttribute(LIST_TYPE)));
int count = reader.NoOfChildren();
reader.MoveDown();
for (int i = 0; i < count; i++)
{
result.Add(context.ConvertAnother());
reader.MoveNext();
}
reader.MoveUp();
return(result);
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
byte[] bytes = null;
int count = reader.NoOfChildren();
if (reader.MoveDown("byte-array"))
{
string base64 = reader.GetValue();
bytes = Convert.FromBase64String(base64);
reader.MoveUp();
}
return(bytes);
}
public object UnMarshall(XStreamReader reader, UnmarshallingContext context, Type type)
{
int count = reader.NoOfChildren();
Array result = Array.CreateInstance(Type.GetType(reader.GetAttribute(ARRAY_TYPE)), count);
if (count != 0) {
reader.MoveDown();
for (int i = 0; i < count; i++) {
var serializedValue = ReadSerializedValue(reader);
var elementType = mapper.ResolveClassTypeFor(serializedValue);
result.SetValue(context.ConvertAnother(result, elementType), i);
reader.MoveNext();
}
reader.MoveUp();
}
return result;
}
private void UnmarshalAs(object result, Type type, XStreamReader reader, UnmarshallingContext context)
{
if (type.Equals(typeof(object))) return;
foreach (var field in mapper.GetSerializableFieldsIn(type))
{
reader.MoveDown(field.SerializedName);
var serializedField = ReadSerializedValue(reader);
var fieldType = mapper.ResolveFieldTypeFor(field, serializedField);
object fieldValue = context.ConvertAnother(result, fieldType);
field.SetValue(result, fieldValue);
reader.MoveUp();
}
UnmarshalAs(result, type.BaseType, reader, context);
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
int count = reader.NoOfChildren();
Array result = Array.CreateInstance(context.GetTypeFromOtherAssemblies(reader.GetAttribute(ARRAY_TYPE)), count);
if (count != 0)
{
reader.MoveDown();
for (int i = 0; i < count; i++)
{
result.SetValue(context.ConvertOriginal(), i);
reader.MoveNext();
}
reader.MoveUp();
}
return(result);
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
IDictionary result = EmptyDictionary(reader);
int count = reader.NoOfChildren();
reader.MoveDown();
for (int i = 0; i < count; i++)
{
reader.MoveDown();
object key = null, value = null;
GetObject(context, ref key, ref value, reader);
reader.MoveNext();
GetObject(context, ref key, ref value, reader);
result.Add(key, value);
reader.MoveUp();
reader.MoveNext();
}
return(result);
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
IList result = (IList)DynamicInstanceBuilder.CreateInstance(context.currentTargetType);
Type elementType = null;
if (context.currentTargetType.HasElementType)
{
elementType = context.currentTargetType.GetElementType();
}
else if (context.currentTargetType.IsGenericType)
{
elementType = context.currentTargetType.GenericTypeArguments[0];
}
else
{
throw new Exception("Unable to get element type for: " + context.currentTargetType.ToString());
}
int count = reader.NoOfChildren();
if (reader.MoveDown() && count > 0)
{
Type previousType = context.currentTargetType;
context.currentTargetType = elementType;
for (int i = 0; i < count; i++)
{
result.Add(context.ConvertAnother(elementType));
Debug.Assert(reader.MoveNext() || result.Count == count);
}
reader.MoveUp();
context.currentTargetType = previousType;
}
return(result);
}
protected override IDictionary EmptyDictionary(XStreamReader reader, UnmarshallingContext context)
{
return(new Hashtable());
}
public Unmarshaller(XStreamReader reader, UnmarshallingContext context, ConverterLookup converterLookup) {
this.reader = reader;
this.context = context;
this.converterLookup = converterLookup;
}
public Unmarshaller(XStreamReader reader, UnmarshallingContext context, ConverterLookup converterLookup)
{
this.reader = reader;
this.context = context;
this.converterLookup = converterLookup;
}
private object ReadItem(XStreamReader reader, UnmarshallingContext context, IList result)
{
var serializedValue = ReadSerializedValue(reader);
var type = mapper.ResolveClassTypeFor(serializedValue);
return context.ConvertAnother(result, type);
}
private static void GetObject(UnmarshallingContext context, ref object key, ref object value, XStreamReader reader)
{
string nodeName = reader.GetNodeName();
object o = context.ConvertOriginal();
if (BaseDictionaryConverter <Hashtable> .KEY.Equals(nodeName))
{
key = o;
}
else
{
value = o;
}
}
protected override IDictionary EmptyDictionary(XStreamReader reader)
{
return(new Hashtable());
}
public object FromXml(XStreamReader reader, UnmarshallingContext context) {
return selfPlugin.operations;
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
return(Enum.Parse(context.currentTargetType, reader.GetValue()));
}
public object FromXml (XStreamReader reader, UnmarshallingContext context) {
throw new System.NotImplementedException ();
}
public object FromXml(XStreamReader reader, UnmarshallingContext context) {
return null;
}
protected override IDictionary EmptyDictionary(XStreamReader reader, UnmarshallingContext context)
{
return((IDictionary)DynamicInstanceBuilder.CreateInstance(context.currentTargetType));
return((IDictionary)DynamicInstanceBuilder.CreateInstance(Type.GetType(reader.GetAttribute(Attributes.classType))));
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
return selfPlugin.Recent;
}
protected override IDictionary EmptyDictionary(XStreamReader reader)
{
return((IDictionary)DynamicInstanceBuilder.CreateInstance(Type.GetType(reader.GetAttribute(Attributes.classType))));
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
return(parse(reader.GetValue()));
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
return(Enum.Parse(Type.GetType(reader.GetAttribute(Attributes.AttributeType)), reader.GetValue()));
}
private static void GetKeyObject(UnmarshallingContext context, ref object key, XStreamReader reader)
{
Type previousType = context.currentTargetType;
Type keyType = context.currentTargetType.GenericTypeArguments[0];
string nodeName = reader.GetNodeName();
context.currentTargetType = keyType;
key = context.ConvertOriginal(keyType);
context.currentTargetType = previousType;
}
public static void SimpleReadWriteTest(bool Compress = true)
{
string[][] LodList = new string[][]
{
new string[] { "Content/Models/monkey.obj", "Content/Models/monkeyLod1.obj", "Content/Models/monkeyLod2.obj" },
new string[] { "Content/Models/squishymonkey.obj", "Content/Models/squishymonkeyLod1.obj" },
new string[] { "Content/Models/HDmonkey.obj", "Content/Models/HDMonkeyLod1.obj", "Content/Models/HDMonkeyLod2.obj", "Content/Models/HDMonkeyLod3.obj" }
};
string[] MetadataStrings = new string[] { "Name:Monkey", "Name:Squishymonkey", "Name:HDmonkey" };
string Ext = "";
EDeflateCompression CompressEnum;
if (Compress)
{
CompressEnum = EDeflateCompression.Compress;
Ext = "x3_c_";
}
else
{
CompressEnum = EDeflateCompression.DoNotCompress;
Ext = "x3_p_";
}
List <HierarchyNode> WriteHNodes = new List <HierarchyNode>();
List <GeometryNode> WritePolygons = new List <GeometryNode>();
List <MetadataNode> WriteMNodes = new List <MetadataNode>();
Random Rand = new Random();
for (int i = 0; i < 3; ++i)
{
HierarchyNode HNode = new HierarchyNode();
HNode.UniqueID = GetId();
MetadataNode Meta = new MetadataNode();
Meta.Metadata = MetadataStrings[i];
Meta.UniqueID = GetId();
var Polygon = new GeometryNode();
for (int f = 0; f < LodList[i].Length; ++f)
{
Obj ObjFile = new Obj();
ObjFile.LoadObj(LodList[i][f]);
SetPolygonData(Polygon, ObjFile, f);
}
Polygon.UniqueID = GetId();
HierarchyNode.GeometryPart Part = CreateGeometryPart(Rand, i, Polygon);
HNode.GeometryParts.Add(Part);
HNode.MetadataID = Meta.UniqueID;
if (i != 0)
{
HNode.ParentID = WriteHNodes[i - 1].UniqueID;
WriteHNodes[i - 1].ChildNodes.Add(HNode.UniqueID);
//HierarchyNode.GeometryPart InstancePart = CreateGeometryPart(Rand, i, WritePolygons[i - 1]);
//HNode.GeometryParts.Add(InstancePart);
}
WriteHNodes.Add(HNode);
WritePolygons.Add(Polygon);
WriteMNodes.Add(Meta);
}
Dictionary <ENodeType, StreamStruct> Streams = new Dictionary <ENodeType, StreamStruct>();
FileStream WriteFileStreamH = new FileStream($"m.{Ext}h", FileMode.Create);
StreamStruct StreamStructH = new StreamStruct(WriteFileStreamH, CompressEnum);
FileStream WriteFileStreamG = new FileStream($"m.{Ext}g", FileMode.Create);
StreamStruct StreamStructG = new StreamStruct(WriteFileStreamG, CompressEnum);
FileStream FileStreamM = new FileStream($"m.{Ext}m", FileMode.Create);
StreamStruct StreamStructM = new StreamStruct(FileStreamM, CompressEnum);
Streams.Add(ENodeType.Hierarchy, StreamStructH);
Streams.Add(ENodeType.Geometry, StreamStructG);
Streams.Add(ENodeType.Metadata, StreamStructM);
Console.WriteLine("Writing");
using (XStreamWriter writer = new XStreamWriter(Streams))
{
for (int i = 0; i < WriteHNodes.Count; ++i)
{
writer.Write(WriteHNodes[i]);
}
for (int i = 0; i < WritePolygons.Count; ++i)
{
writer.Write(WritePolygons[i]);
}
for (int i = 0; i < WriteMNodes.Count; ++i)
{
writer.Write(WriteMNodes[i]);
}
}
//Dispose of stream here
Streams[ENodeType.Hierarchy].IOStream.Dispose();
Streams[ENodeType.Metadata].IOStream.Dispose();
Streams[ENodeType.Geometry].IOStream.Dispose();
Console.WriteLine("Done writing");
Console.WriteLine("Reading");
List <GeometryNode> ReadPolygons = new List <GeometryNode>();
List <HierarchyNode> ReadHNodes = new List <HierarchyNode>();
List <MetadataNode> ReadMNodes = new List <MetadataNode>();
ManualResetEvent WaitReads = new ManualResetEvent(false);
int ReadsLeft = WriteHNodes.Count + WriteMNodes.Count + WritePolygons.Count;
FileStream ReadFileStreamH = new FileStream($"m.{Ext}h", FileMode.Open);
FileStream ReadFileStreamG = new FileStream($"m.{Ext}g", FileMode.Open);
FileStream ReadFileStreamM = new FileStream($"m.{Ext}m", FileMode.Open);
using (XStreamReader ReaderH = new XStreamReader(ENodeType.Hierarchy, ReadFileStreamH,
(_Sdk) =>
{
},
(_Node) =>
{
Interlocked.Decrement(ref ReadsLeft);
lock (ReadHNodes)
{
ReadHNodes.Add((HierarchyNode)_Node);
}
if (ReadsLeft == 0)
{
WaitReads.Set();
}
}, CompressEnum))
{
if (!ReaderH.Process(Console.WriteLine))
{
throw new Exception("Failed");
}
}
using (XStreamReader ReaderM = new XStreamReader(ENodeType.Metadata, ReadFileStreamM,
(_Sdk) =>
{
},
(_Node) =>
{
Interlocked.Decrement(ref ReadsLeft);
lock (ReadMNodes)
{
ReadMNodes.Add((MetadataNode)_Node);
}
if (ReadsLeft == 0)
{
WaitReads.Set();
}
}, CompressEnum))
{
if (!ReaderM.Process(Console.WriteLine))
{
throw new Exception("Failed");
}
}
using (XStreamReader ReaderG = new XStreamReader(ENodeType.Geometry, ReadFileStreamG,
(_Sdk) =>
{
},
(_Node) =>
{
Interlocked.Decrement(ref ReadsLeft);
lock (ReadPolygons)
{
ReadPolygons.Add((GeometryNode)_Node);
}
if (ReadsLeft == 0)
{
WaitReads.Set();
}
}, CompressEnum))
{
if (!ReaderG.Process(Console.WriteLine))
{
throw new Exception("Failed");
}
}
WaitReads.WaitOne();
Console.WriteLine("Done Reading");
WritePolygons = WritePolygons.OrderBy(x => x.UniqueID).ToList();
ReadPolygons = ReadPolygons.OrderBy(x => x.UniqueID).ToList();
WriteMNodes = WriteMNodes.OrderBy(x => x.UniqueID).ToList();
ReadMNodes = ReadMNodes.OrderBy(x => x.UniqueID).ToList();
WriteHNodes = WriteHNodes.OrderBy(x => x.UniqueID).ToList();
ReadHNodes = ReadHNodes.OrderBy(x => x.UniqueID).ToList();
CheckInputVsOutput(WritePolygons, WriteHNodes, WriteMNodes, ReadPolygons, ReadHNodes, ReadMNodes);
}
private static void GetValueObject(UnmarshallingContext context, ref object value, XStreamReader reader)
{
Type previousType = context.currentTargetType;
Type valueType = context.currentTargetType.GenericTypeArguments[1];
string nodeName = reader.GetNodeName();
context.currentTargetType = valueType;
value = context.ConvertOriginal(valueType);
context.currentTargetType = previousType;
}
protected abstract IDictionary EmptyDictionary(XStreamReader reader);
internal UnmarshallingContext(XStreamReader reader, ConverterLookup converterLookup, Aliases aliases, List<Assembly> assemblies) {
this.reader = reader;
this.converterLookup = converterLookup;
this.aliases = aliases;
this.assemblies = assemblies;
}
public object UnMarshall(XStreamReader reader, UnmarshallingContext context, Type type)
{
return Enum.Parse(Type.GetType(reader.GetAttribute(XsAttribute.AttributeType)), reader.GetValue());
}
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
throw new System.NotImplementedException();
}
internal UnmarshallingContext(XStreamReader reader, ConverterLookup converterLookup, IMapper mapper)
{
this.reader = reader;
this.converterLookup = converterLookup;
this.mapper = mapper;
}
public object FromXml(XStreamReader reader, UnmarshallingContext context) {
return Enum.Parse(Type.GetType(reader.GetAttribute(Attributes.AttributeType)), reader.GetValue());
}
protected abstract IDictionary EmptyDictionary(XStreamReader reader, UnmarshallingContext context);
public object FromXml(XStreamReader reader, UnmarshallingContext context)
{
return(null);
}
