public static void SerializeTypeless(object obj, BinaryWriter writer)
{
Type type = obj.GetType();
SerializationTemplate serializationTemplate = Manager.GetSerializationTemplate(type);
serializationTemplate.SerializeData(obj, writer);
}
public static void Serialize(object obj, BinaryWriter writer)
{
Type type = obj.GetType();
SerializationTemplate serializationTemplate = Manager.GetSerializationTemplate(type);
string kTypeString = obj.GetType().GetKTypeString();
writer.WriteKleiString(kTypeString);
serializationTemplate.SerializeData(obj, writer);
}
public static SerializationTemplate GetSerializationTemplate(Type type)
{
if (type == null)
{
throw new InvalidOperationException("Invalid type encountered when serializing");
}
SerializationTemplate value = null;
if (!serializationTemplatesByType.TryGetValue(type, out value))
{
value = new SerializationTemplate(type);
serializationTemplatesByType[type] = value;
serializationTemplatesByTypeName[type.GetKTypeString()] = value;
}
return(value);
}
public static DeserializationMapping GetDeserializationMapping(string type_name)
{
DeserializationTemplate deserializationTemplate = GetDeserializationTemplate(type_name);
if (deserializationTemplate == null)
{
throw new ArgumentException("Tried to deserialize a class named: " + type_name + " but no such class exists");
}
SerializationTemplate serializationTemplate = GetSerializationTemplate(type_name);
if (serializationTemplate == null)
{
throw new ArgumentException("Tried to deserialize into a class named: " + type_name + " but no such class exists");
}
return(GetMapping(deserializationTemplate, serializationTemplate));
}
public static void SerializeDirectory(BinaryWriter writer)
{
writer.Write(serializationTemplatesByTypeName.Count);
foreach (KeyValuePair <string, SerializationTemplate> item in serializationTemplatesByTypeName)
{
string key = item.Key;
SerializationTemplate value = item.Value;
try
{
writer.WriteKleiString(key);
value.SerializeTemplate(writer);
}
catch (Exception ex)
{
DebugUtil.LogErrorArgs("Error serializing template " + key + "\n", ex.Message, ex.StackTrace);
}
}
}
public static SerializationTemplate GetSerializationTemplate(string type_name)
{
if (type_name == null || type_name == string.Empty)
{
throw new InvalidOperationException("Invalid type name encountered when serializing");
}
SerializationTemplate value = null;
if (!serializationTemplatesByTypeName.TryGetValue(type_name, out value))
{
Type type = GetType(type_name);
if (type != null)
{
value = new SerializationTemplate(type);
serializationTemplatesByType[type] = value;
serializationTemplatesByTypeName[type_name] = value;
}
}
return(value);
}
private static DeserializationMapping GetMapping(DeserializationTemplate dtemplate, SerializationTemplate stemplate)
{
DeserializationMapping deserializationMapping = null;
if (deserializationMappings.TryGetValue(dtemplate, out KeyValuePair <SerializationTemplate, DeserializationMapping> value))
{
deserializationMapping = value.Value;
}
else
{
deserializationMapping = new DeserializationMapping(dtemplate, stemplate);
value = new KeyValuePair <SerializationTemplate, DeserializationMapping>(stemplate, deserializationMapping);
deserializationMappings[dtemplate] = value;
}
return(deserializationMapping);
}
public static void WriteValue(this BinaryWriter writer, TypeInfo type_info, object value)
{
switch (type_info.info & SerializationTypeInfo.VALUE_MASK)
{
case SerializationTypeInfo.SByte:
writer.Write((sbyte)value);
break;
case SerializationTypeInfo.Byte:
writer.Write((byte)value);
break;
case SerializationTypeInfo.Boolean:
writer.Write((byte)(((bool)value) ? 1 : 0));
break;
case SerializationTypeInfo.Int16:
writer.Write((short)value);
break;
case SerializationTypeInfo.UInt16:
writer.Write((ushort)value);
break;
case SerializationTypeInfo.Int32:
writer.Write((int)value);
break;
case SerializationTypeInfo.UInt32:
writer.Write((uint)value);
break;
case SerializationTypeInfo.Int64:
writer.Write((long)value);
break;
case SerializationTypeInfo.UInt64:
writer.Write((ulong)value);
break;
case SerializationTypeInfo.Single:
writer.Write((float)value);
break;
case SerializationTypeInfo.Double:
writer.Write((double)value);
break;
case SerializationTypeInfo.String:
writer.WriteKleiString((string)value);
break;
case SerializationTypeInfo.Enumeration:
writer.Write((int)value);
break;
case SerializationTypeInfo.Vector2I:
{
Vector2I vector2I = (Vector2I)value;
writer.Write(vector2I.x);
writer.Write(vector2I.y);
break;
}
case SerializationTypeInfo.Vector2:
{
Vector2 vector = (Vector2)value;
writer.Write(vector.x);
writer.Write(vector.y);
break;
}
case SerializationTypeInfo.Vector3:
{
Vector3 vector2 = (Vector3)value;
writer.Write(vector2.x);
writer.Write(vector2.y);
writer.Write(vector2.z);
break;
}
case SerializationTypeInfo.Colour:
{
Color color = (Color)value;
writer.Write((byte)(color.r * 255f));
writer.Write((byte)(color.g * 255f));
writer.Write((byte)(color.b * 255f));
writer.Write((byte)(color.a * 255f));
break;
}
case SerializationTypeInfo.Array:
if (value != null)
{
Array array = value as Array;
TypeInfo typeInfo3 = type_info.subTypes[0];
long position16 = writer.BaseStream.Position;
writer.Write(0);
writer.Write(array.Length);
long position17 = writer.BaseStream.Position;
if (IsPOD(typeInfo3.info))
{
WriteArrayFast(writer, typeInfo3, array);
}
else if (IsValueType(typeInfo3.info))
{
SerializationTemplate serializationTemplate4 = Manager.GetSerializationTemplate(typeInfo3.type);
for (int i = 0; i < array.Length; i++)
{
serializationTemplate4.SerializeData(array.GetValue(i), writer);
}
}
else
{
for (int j = 0; j < array.Length; j++)
{
writer.WriteValue(typeInfo3, array.GetValue(j));
}
}
long position18 = writer.BaseStream.Position;
long num7 = position18 - position17;
writer.BaseStream.Position = position16;
writer.Write((int)num7);
writer.BaseStream.Position = position18;
}
else
{
writer.Write(4);
writer.Write(-1);
}
break;
case SerializationTypeInfo.UserDefined:
if (value != null)
{
long position7 = writer.BaseStream.Position;
writer.Write(0);
long position8 = writer.BaseStream.Position;
SerializationTemplate serializationTemplate3 = Manager.GetSerializationTemplate(type_info.type);
serializationTemplate3.SerializeData(value, writer);
long position9 = writer.BaseStream.Position;
long num4 = position9 - position8;
writer.BaseStream.Position = position7;
writer.Write((int)num4);
writer.BaseStream.Position = position9;
}
else
{
writer.Write(-1);
}
break;
case SerializationTypeInfo.HashSet:
if (value != null)
{
TypeInfo typeInfo2 = type_info.subTypes[0];
long position4 = writer.BaseStream.Position;
writer.Write(0);
writer.Write(0);
long position5 = writer.BaseStream.Position;
int num2 = 0;
IEnumerable enumerable = value as IEnumerable;
if (IsValueType(typeInfo2.info))
{
SerializationTemplate serializationTemplate2 = Manager.GetSerializationTemplate(typeInfo2.type);
IEnumerator enumerator3 = enumerable.GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
object current3 = enumerator3.Current;
serializationTemplate2.SerializeData(current3, writer);
num2++;
}
}
finally
{
IDisposable disposable3;
if ((disposable3 = (enumerator3 as IDisposable)) != null)
{
disposable3.Dispose();
}
}
}
else
{
IEnumerator enumerator4 = enumerable.GetEnumerator();
try
{
while (enumerator4.MoveNext())
{
object current4 = enumerator4.Current;
writer.WriteValue(typeInfo2, current4);
num2++;
}
}
finally
{
IDisposable disposable4;
if ((disposable4 = (enumerator4 as IDisposable)) != null)
{
disposable4.Dispose();
}
}
}
long position6 = writer.BaseStream.Position;
long num3 = position6 - position5;
writer.BaseStream.Position = position4;
writer.Write((int)num3);
writer.Write(num2);
writer.BaseStream.Position = position6;
}
else
{
writer.Write(4);
writer.Write(-1);
}
break;
case SerializationTypeInfo.List:
if (value != null)
{
TypeInfo typeInfo4 = type_info.subTypes[0];
ICollection collection2 = value as ICollection;
long position19 = writer.BaseStream.Position;
writer.Write(0);
writer.Write(collection2.Count);
long position20 = writer.BaseStream.Position;
if (IsPOD(typeInfo4.info))
{
WriteListPOD(writer, typeInfo4, collection2);
}
else if (IsValueType(typeInfo4.info))
{
SerializationTemplate serializationTemplate5 = Manager.GetSerializationTemplate(typeInfo4.type);
IEnumerator enumerator7 = collection2.GetEnumerator();
try
{
while (enumerator7.MoveNext())
{
object current7 = enumerator7.Current;
serializationTemplate5.SerializeData(current7, writer);
}
}
finally
{
IDisposable disposable7;
if ((disposable7 = (enumerator7 as IDisposable)) != null)
{
disposable7.Dispose();
}
}
}
else
{
IEnumerator enumerator8 = collection2.GetEnumerator();
try
{
while (enumerator8.MoveNext())
{
object current8 = enumerator8.Current;
writer.WriteValue(typeInfo4, current8);
}
}
finally
{
IDisposable disposable8;
if ((disposable8 = (enumerator8 as IDisposable)) != null)
{
disposable8.Dispose();
}
}
}
long position21 = writer.BaseStream.Position;
long num8 = position21 - position20;
writer.BaseStream.Position = position19;
writer.Write((int)num8);
writer.BaseStream.Position = position21;
}
else
{
writer.Write(4);
writer.Write(-1);
}
break;
case SerializationTypeInfo.Dictionary:
if (value != null)
{
TypeInfo type_info4 = type_info.subTypes[0];
TypeInfo type_info5 = type_info.subTypes[1];
IDictionary dictionary = value as IDictionary;
ICollection keys = dictionary.Keys;
ICollection values = dictionary.Values;
long position13 = writer.BaseStream.Position;
writer.Write(0);
writer.Write(values.Count);
long position14 = writer.BaseStream.Position;
IEnumerator enumerator5 = values.GetEnumerator();
try
{
while (enumerator5.MoveNext())
{
object current5 = enumerator5.Current;
writer.WriteValue(type_info5, current5);
}
}
finally
{
IDisposable disposable5;
if ((disposable5 = (enumerator5 as IDisposable)) != null)
{
disposable5.Dispose();
}
}
IEnumerator enumerator6 = keys.GetEnumerator();
try
{
while (enumerator6.MoveNext())
{
object current6 = enumerator6.Current;
writer.WriteValue(type_info4, current6);
}
}
finally
{
IDisposable disposable6;
if ((disposable6 = (enumerator6 as IDisposable)) != null)
{
disposable6.Dispose();
}
}
long position15 = writer.BaseStream.Position;
long num6 = position15 - position14;
writer.BaseStream.Position = position13;
writer.Write((int)num6);
writer.BaseStream.Position = position15;
}
else
{
writer.Write(4);
writer.Write(-1);
}
break;
case SerializationTypeInfo.Pair:
if (value != null)
{
PropertyInfo property = type_info.type.GetProperty("Key");
PropertyInfo property2 = type_info.type.GetProperty("Value");
object value2 = property.GetValue(value, null);
object value3 = property2.GetValue(value, null);
TypeInfo type_info2 = type_info.subTypes[0];
TypeInfo type_info3 = type_info.subTypes[1];
long position10 = writer.BaseStream.Position;
writer.Write(0);
long position11 = writer.BaseStream.Position;
writer.WriteValue(type_info2, value2);
writer.WriteValue(type_info3, value3);
long position12 = writer.BaseStream.Position;
long num5 = position12 - position11;
writer.BaseStream.Position = position10;
writer.Write((int)num5);
writer.BaseStream.Position = position12;
}
else
{
writer.Write(4);
writer.Write(-1);
}
break;
case SerializationTypeInfo.Queue:
if (value != null)
{
TypeInfo typeInfo = type_info.subTypes[0];
ICollection collection = value as ICollection;
long position = writer.BaseStream.Position;
writer.Write(0);
writer.Write(collection.Count);
long position2 = writer.BaseStream.Position;
if (IsPOD(typeInfo.info))
{
WriteListPOD(writer, typeInfo, collection);
}
else if (IsValueType(typeInfo.info))
{
SerializationTemplate serializationTemplate = Manager.GetSerializationTemplate(typeInfo.type);
IEnumerator enumerator = collection.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object current = enumerator.Current;
serializationTemplate.SerializeData(current, writer);
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
else
{
IEnumerator enumerator2 = collection.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
object current2 = enumerator2.Current;
writer.WriteValue(typeInfo, current2);
}
}
finally
{
IDisposable disposable2;
if ((disposable2 = (enumerator2 as IDisposable)) != null)
{
disposable2.Dispose();
}
}
}
long position3 = writer.BaseStream.Position;
long num = position3 - position2;
writer.BaseStream.Position = position;
writer.Write((int)num);
writer.BaseStream.Position = position3;
}
else
{
writer.Write(4);
writer.Write(-1);
}
break;
default:
throw new ArgumentException("Don't know how to serialize type: " + type_info.type.ToString());
}
}
