private static Type ReadDictionaryType(IBinaryReader reader, out ReadDelegate keyReadDelegate, out ReadDelegate valueReadDelegate)
{
Type clrArrayType;
Type type4;
GpType gpType = (GpType)reader.ReadByte();
GpType type2 = (GpType)reader.ReadByte();
if (gpType == GpType.Unknown)
{
clrArrayType = typeof(object);
keyReadDelegate = new ReadDelegate(GpBinaryByteReader.Read);
}
else
{
clrArrayType = GpBinaryByteTypeConverter.GetClrArrayType(gpType);
keyReadDelegate = GetReadDelegate(gpType);
}
if (type2 == GpType.Unknown)
{
type4 = typeof(object);
valueReadDelegate = new ReadDelegate(GpBinaryByteReader.Read);
}
else
{
type4 = GpBinaryByteTypeConverter.GetClrArrayType(type2);
valueReadDelegate = GetReadDelegate(type2);
}
return(typeof(Dictionary <,>).MakeGenericType(new Type[] { clrArrayType, type4 }));
}
private static void WriteDictionary(IBinaryWriter writer, object dict)
{
Type[] genericArguments = dict.GetType().GetGenericArguments();
bool setType = genericArguments[0] == typeof(object);
bool flag2 = genericArguments[1] == typeof(object);
if (setType)
{
writer.WriteByte(0);
}
else
{
GpType gpType = GpBinaryByteTypeConverter.GetGpType(genericArguments[0]);
switch (gpType)
{
case GpType.Unknown:
case GpType.Dictionary:
throw new InvalidDataException("Unexpected - cannot serialize Dictionary with key type: " + genericArguments[0]);
}
writer.WriteByte((byte)gpType);
}
if (flag2)
{
writer.WriteByte(0);
}
else
{
GpType type2 = GpBinaryByteTypeConverter.GetGpType(genericArguments[1]);
if (type2 == GpType.Unknown)
{
CustomTypeInfo info;
if (!CustomTypeCache.TryGet(genericArguments[1], out info))
{
throw new InvalidDataException("Unexpected - cannot serialize Dictionary with value type: " + genericArguments[1]);
}
writer.WriteByte(0x63);
writer.WriteByte(info.Code);
}
else
{
writer.WriteByte((byte)type2);
if (type2 == GpType.Dictionary)
{
WriteDictionaryHeader(writer, genericArguments[1]);
}
else if ((type2 == GpType.Array) && !WriteArrayHeader(writer, genericArguments[1].GetElementType()))
{
throw new InvalidDataException("Unexpected - cannot serialize Dictionary with value type: " + genericArguments[1]);
}
}
}
IDictionary dictionary = (IDictionary)dict;
writer.WriteInt16((short)dictionary.Count);
foreach (DictionaryEntry entry in dictionary)
{
Write(writer, entry.Key, setType);
Write(writer, entry.Value, flag2);
}
}
private static Type ReadDictionaryType(IBinaryReader reader)
{
Type clrArrayType;
Type dictArrayType;
GpType gpType = (GpType)reader.ReadByte();
GpType type2 = (GpType)reader.ReadByte();
if (gpType == GpType.Unknown)
{
clrArrayType = typeof(object);
}
else
{
clrArrayType = GpBinaryByteTypeConverter.GetClrArrayType(gpType);
}
switch (type2)
{
case GpType.Unknown:
dictArrayType = typeof(object);
break;
case GpType.Dictionary:
dictArrayType = ReadDictionaryType(reader);
break;
case GpType.Array:
dictArrayType = GetDictArrayType(reader);
break;
default:
dictArrayType = GpBinaryByteTypeConverter.GetClrArrayType(type2);
break;
}
return(typeof(Dictionary <,>).MakeGenericType(new Type[] { clrArrayType, dictArrayType }));
}
/// <summary>
/// Writes an array.
/// </summary>
/// <param name="writer"> The writer.</param>
/// <param name="serObject">The ser object.</param>
private static void WriteArray(IBinaryWriter writer, IList serObject)
{
Type elementType = serObject.GetType().GetElementType();
GpType gpType = GpBinaryByteTypeConverter.GetGpType(elementType);
if (gpType == GpType.Unknown)
{
if (elementType == typeof(RawCustomArray))
{
writer.WriteInt16((short)serObject.Count);
for (int i = 0; i < serObject.Count; i++)
{
WriteCustomTypeArray(writer, (RawCustomArray)serObject[i], i == 0);
}
}
else
{
CustomTypeInfo info;
if (!CustomTypeCache.TryGet(elementType, out info))
{
throw new InvalidDataException(string.Format("Arrays of type '{0}' are not supported.", elementType));
}
WriteCustomTypeArray(writer, info, serObject);
}
}
else
{
writer.WriteInt16((short)serObject.Count);
writer.WriteByte((byte)gpType);
if (gpType == GpType.Dictionary)
{
bool flag;
bool flag2;
WriteDictionaryHeader(writer, serObject, out flag, out flag2);
foreach (object obj2 in serObject)
{
WriteDictionaryElements(writer, obj2, flag, flag2);
}
}
else
{
foreach (object obj3 in serObject)
{
Write(writer, obj3, false);
}
}
}
}
private static bool WriteArrayHeader(IBinaryWriter writer, Type type)
{
while (type.IsArray)
{
writer.WriteByte(0x79);
type = type.GetElementType();
}
GpType gpType = GpBinaryByteTypeConverter.GetGpType(type);
if (gpType == GpType.Unknown)
{
return(false);
}
writer.WriteByte((byte)gpType);
return(true);
}
// Methods
private static Type GetDictArrayType(IBinaryReader reader)
{
GpType gpType = (GpType)reader.ReadByte();
int num = 0;
while (gpType == GpType.Array)
{
num++;
gpType = (GpType)reader.ReadByte();
}
Type type3 = GpBinaryByteTypeConverter.GetClrArrayType(gpType).MakeArrayType();
for (int i = 0; i < num; i++)
{
type3 = type3.MakeArrayType();
}
return(type3);
}
private static void WriteDictionaryHeader(IBinaryWriter writer, Type dictType)
{
Type[] genericArguments = dictType.GetGenericArguments();
if (genericArguments[0] == typeof(object))
{
writer.WriteByte(0);
}
else
{
GpType gpType = GpBinaryByteTypeConverter.GetGpType(genericArguments[0]);
switch (gpType)
{
case GpType.Unknown:
case GpType.Dictionary:
throw new InvalidDataException("Unexpected - cannot serialize Dictionary with key type: " + genericArguments[0]);
}
writer.WriteByte((byte)gpType);
}
if (genericArguments[1] == typeof(object))
{
writer.WriteByte(0);
}
else
{
GpType type2 = GpBinaryByteTypeConverter.GetGpType(genericArguments[1]);
if (type2 == GpType.Unknown)
{
throw new InvalidDataException("Unexpected - cannot serialize Dictionary with value type: " + genericArguments[1]);
}
writer.WriteByte((byte)type2);
if (type2 == GpType.Dictionary)
{
WriteDictionaryHeader(writer, genericArguments[1]);
}
else if ((type2 == GpType.Array) && !WriteArrayHeader(writer, genericArguments[1].GetElementType()))
{
throw new InvalidDataException("Unexpected - cannot serialize Dictionary with value type: " + genericArguments[1]);
}
}
}
/// <summary>
/// Reads an <see cref="T:System.Collections.ArrayList"/> objects from a specified <see cref="T:ExitGames.IO.IBinaryReader"/>
/// </summary>
/// <param name="reader">The <see cref="T:ExitGames.IO.IBinaryReader"/> to read from.</param>
/// <param name="result">When this method returns true, contains the <see cref="T:System.Collections.ArrayList"/> that was read from the <see cref="T:ExitGames.IO.IBinaryReader"/>.</param>
/// <returns>True if the value was successfully read; otherwise false.</returns>
public static bool ReadVector(IBinaryReader reader, out object result)
{
short capacity = reader.ReadInt16();
if (capacity == 0)
{
result = new ArrayList(0);
return(true);
}
GpType gpType = (GpType)((byte)reader.ReadChar());
int gpTypeSize = GpBinaryByteTypeConverter.GetGpTypeSize(gpType);
if ((capacity < 0) || ((reader.BaseStream.Length - reader.BaseStream.Position) < (capacity * gpTypeSize)))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Invalid length for vector of type {2}: length={0}, bytesLeft={1}", new object[] { capacity, reader.BaseStream.Length - reader.BaseStream.Position, gpType });
}
result = null;
return(false);
}
ArrayList list = new ArrayList(capacity);
for (int i = 0; i < capacity; i++)
{
object obj2;
if (Read(reader, gpType, out obj2))
{
list.Add(obj2);
}
else
{
result = null;
return(false);
}
}
result = list;
return(true);
}
/// <summary>
/// Serializes an object.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="value">The object to write.</param>
/// <param name="setType">The set type.</param>
/// <exception cref="T:System.IO.InvalidDataException">
/// The type of the <paramref name="value"/> can not be serialized.
/// </exception>
/// <exception cref="T:System.ArrayTypeMismatchException">
/// A collection with different types can not be serialized.
/// </exception>
private static void Write(IBinaryWriter writer, object value, bool setType)
{
Type type = (value == null) ? null : value.GetType();
GpType gpType = GpBinaryByteTypeConverter.GetGpType(type);
GpType type3 = gpType;
if (type3 != GpType.Unknown)
{
if ((type3 == GpType.Array) && (value is byte[]))
{
gpType = GpType.ByteArray;
}
}
else
{
CustomTypeInfo info;
if (type == typeof(RawCustomArray))
{
WriteCustomTypeArray(writer, (RawCustomArray)value, true);
return;
}
if (CustomTypeCache.TryGet(type, out info))
{
if (setType)
{
writer.WriteByte(0x63);
}
WriteCustomType(writer, info, value);
return;
}
if (type != typeof(RawCustomValue))
{
throw new InvalidDataException("cannot serialize(): " + type);
}
if (setType)
{
writer.WriteByte(0x63);
}
WriteCustomType(writer, (RawCustomValue)value);
return;
}
if (setType)
{
writer.WriteByte((byte)gpType);
}
GpType type4 = gpType;
if (type4 != GpType.Null)
{
switch (type4)
{
case GpType.Byte:
writer.WriteByte((byte)value);
return;
case GpType.Custom:
WriteCustomType(writer, (RawCustomValue)value);
return;
case GpType.Double:
writer.WriteDouble((double)value);
return;
case GpType.EventData:
WriteEventData(writer, (EventData)value);
return;
case GpType.Float:
writer.WriteSingle((float)value);
return;
case GpType.Hashtable:
WriteHashTable(writer, (Hashtable)value);
return;
case GpType.Integer:
writer.WriteInt32((int)value);
return;
case GpType.Short:
writer.WriteInt16((short)value);
return;
case GpType.Long:
writer.WriteInt64((long)value);
return;
case GpType.Boolean:
writer.WriteBoolean((bool)value);
return;
case GpType.OperationResponse:
WriteOperationResponse(writer, (OperationResponse)value);
return;
case GpType.OperationRequest:
WriteOperationRequest(writer, (OperationRequest)value);
return;
case GpType.String:
writer.WriteUTF((string)value);
return;
case GpType.Vector:
WriteVector(writer, (IList)value);
return;
case GpType.ByteArray:
WriteByteArray(writer, (byte[])value);
return;
case GpType.Array:
WriteArray(writer, (IList)value);
return;
case GpType.ObjectArray:
WriteObjectArray(writer, (IList)value);
return;
case GpType.Dictionary:
WriteDictionary(writer, value);
return;
}
}
else
{
if (!setType)
{
throw new InvalidOperationException("cannot serialize null values inside an array");
}
return;
}
throw new InvalidDataException("Unexpected - cannot serialize gp type: " + gpType);
}
private static bool ReadDictionary(IBinaryReader reader, out object result)
{
ReadDelegate readDelegate;
Type clrArrayType;
ReadDelegate delegate3;
Type dictArrayType;
result = null;
GpType gpType = (GpType)reader.ReadByte();
if (gpType == GpType.Unknown)
{
clrArrayType = typeof(object);
readDelegate = new ReadDelegate(GpBinaryByteReader.Read);
}
else
{
clrArrayType = GpBinaryByteTypeConverter.GetClrArrayType(gpType);
readDelegate = GetReadDelegate(gpType);
}
GpType type3 = (GpType)reader.ReadByte();
switch (type3)
{
case GpType.Unknown:
dictArrayType = typeof(object);
delegate3 = new ReadDelegate(GpBinaryByteReader.Read);
break;
case GpType.Dictionary:
dictArrayType = ReadDictionaryType(reader);
delegate3 = new ReadDelegate(GpBinaryByteReader.ReadDictionary);
break;
case GpType.Array:
dictArrayType = GetDictArrayType(reader);
delegate3 = new ReadDelegate(GpBinaryByteReader.ReadArray);
break;
case GpType.ObjectArray:
dictArrayType = typeof(object[]);
delegate3 = new ReadDelegate(GpBinaryByteReader.ReadObjectArray);
break;
case GpType.Custom:
CustomTypeInfo info;
if (!CustomTypeCache.TryGet(reader.ReadByte(), out info))
{
return(false);
}
dictArrayType = info.Type;
delegate3 = new ReadDelegate(GpBinaryByteReader.ReadCustomType);
break;
default:
dictArrayType = GpBinaryByteTypeConverter.GetClrArrayType(type3);
delegate3 = GetReadDelegate(type3);
if ((dictArrayType == null) || (delegate3 == null))
{
return(false);
}
break;
}
IDictionary dictionary = Activator.CreateInstance(typeof(Dictionary <,>).MakeGenericType(new Type[] { clrArrayType, dictArrayType })) as IDictionary;
if (dictionary == null)
{
return(false);
}
short num2 = reader.ReadInt16();
for (int i = 0; i < num2; i++)
{
object obj2;
object obj3;
if (!readDelegate(reader, out obj2))
{
return(false);
}
if (!delegate3(reader, out obj3))
{
return(false);
}
dictionary.Add(obj2, obj3);
}
result = dictionary;
return(true);
}
/// <summary>
/// Reads an array from a specified <see cref="T:ExitGames.IO.IBinaryReader"/>
/// </summary>
/// <param name="binaryReader">The <see cref="T:ExitGames.IO.IBinaryReader"/> to read from.</param>
/// <param name="result">When this method returns true, contains the array that was read from the <see cref="T:ExitGames.IO.IBinaryReader"/>.</param>
/// <returns>True if the value was successfully read; otherwise false.</returns>
internal static bool ReadArray(IBinaryReader binaryReader, out object result)
{
short size = binaryReader.ReadInt16();
byte num2 = binaryReader.ReadByte();
GpType gpType = (GpType)num2;
if (gpType == GpType.Dictionary)
{
return(ReadDictionaryArray(binaryReader, size, out result));
}
int num3 = 1;
Type clrArrayType = GpBinaryByteTypeConverter.GetClrArrayType(gpType, ref num3);
if ((size < 0) || ((size * num3) > (binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Invalid length for array of type {2}: length={0}, bytesLeft={1}", new object[] { size, binaryReader.BaseStream.Length - binaryReader.BaseStream.Position, gpType });
}
result = null;
return(false);
}
switch (gpType)
{
case GpType.Custom:
return(ReadCustomTypeArray(binaryReader, size, out result));
case GpType.Array:
return(ReadArrayInArray(binaryReader, size, out result));
}
if (clrArrayType == null)
{
if (log.IsDebugEnabled)
{
if (gpType == GpType.Unknown)
{
log.DebugFormat("Array of unknown type {0} is not supported.", new object[] { num2 });
}
else
{
log.DebugFormat("Array of type {0} is not supported.", new object[] { gpType });
}
}
result = null;
return(false);
}
Array array = Array.CreateInstance(clrArrayType, size);
for (short i = 0; i < size; i = (short)(i + 1))
{
object obj2;
if (Read(binaryReader, gpType, out obj2))
{
array.SetValue(obj2, (int)i);
}
else
{
result = null;
return(false);
}
}
result = array;
return(true);
}
