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 Type DeserializeDictionaryType(MemoryStream reader, out byte keyTypeCode, out byte valTypeCode)
{
Type keyClrType;
Type valueClrType;
keyTypeCode = (byte)reader.ReadByte();
valTypeCode = (byte)reader.ReadByte();
GpType keyType = (GpType)keyTypeCode;
GpType valueType = (GpType)valTypeCode;
if (keyType == GpType.Unknown)
{
keyClrType = typeof(object);
}
else
{
keyClrType = GetTypeOfCode(keyTypeCode);
}
if (valueType == GpType.Unknown)
{
valueClrType = typeof(object);
}
else
{
valueClrType = GetTypeOfCode(valTypeCode);
}
return(typeof(Dictionary <,>).MakeGenericType(new Type[] { keyClrType, valueClrType }));
}
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 }));
}
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);
}
}
/// <summary>
/// Gets the minimum size for a type.
/// </summary>
/// <param name="gpType"> The gp type.</param>
/// <returns> The minimum size.</returns>
public static int GetGpTypeSize(GpType gpType)
{
switch (gpType)
{
case GpType.StringArray:
return(2);
case GpType.Byte:
return(1);
case GpType.Double:
return(8);
case GpType.EventData:
return(3);
case GpType.Float:
return(4);
case GpType.Hashtable:
return(2);
case GpType.Integer:
return(4);
case GpType.Short:
return(2);
case GpType.Long:
return(8);
case GpType.IntegerArray:
return(4);
case GpType.Boolean:
return(1);
case GpType.OperationResponse:
return(3);
case GpType.OperationRequest:
return(3);
case GpType.String:
return(2);
case GpType.Vector:
return(2);
case GpType.ByteArray:
return(4);
case GpType.Array:
return(4);
case GpType.Null:
return(0);
}
return(1);
}
/// <summary>
/// The get gp type.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>the gpType</returns>
public static GpType GetGpType(Type type)
{
if (type == null)
{
return(GpType.Null);
}
GpType gpType = GetGpType(Type.GetTypeCode(type));
if (gpType != GpType.Unknown)
{
return(gpType);
}
if (type == typeof(Hashtable))
{
return(GpType.Hashtable);
}
if (typeof(IEventData).IsAssignableFrom(type))
{
return(GpType.EventData);
}
if (type == typeof(OperationResponse))
{
return(GpType.OperationResponse);
}
if (type == typeof(OperationRequest))
{
return(GpType.OperationRequest);
}
if (type.IsArray)
{
Type elementType = type.GetElementType();
if (elementType == typeof(byte))
{
return(GpType.ByteArray);
}
if (elementType == typeof(object))
{
return(GpType.ObjectArray);
}
return(GpType.Array);
}
if (typeof(IList).IsAssignableFrom(type))
{
return(GpType.Vector);
}
if (type == typeof(RawCustomValue))
{
return(GpType.Custom);
}
if (type.IsGenericType)
{
Type genericTypeDefinition = type.GetGenericTypeDefinition();
if (typeof(Dictionary <,>) == genericTypeDefinition)
{
return(GpType.Dictionary);
}
}
return(GpType.Unknown);
}
private static ReadDelegate GetReadDelegate(GpType gpType)
{
switch (gpType)
{
case GpType.StringArray:
return(new ReadDelegate(GpBinaryByteReader.ReadStringArray));
case GpType.Byte:
return(new ReadDelegate(GpBinaryByteReader.ReadByte));
case GpType.Custom:
return(new ReadDelegate(GpBinaryByteReader.ReadCustomType));
case GpType.Double:
return(new ReadDelegate(GpBinaryByteReader.ReadDouble));
case GpType.Float:
return(new ReadDelegate(GpBinaryByteReader.ReadSingle));
case GpType.Hashtable:
return(new ReadDelegate(GpBinaryByteReader.ReadHashTable));
case GpType.Integer:
return(new ReadDelegate(GpBinaryByteReader.ReadInt32));
case GpType.Short:
return(new ReadDelegate(GpBinaryByteReader.ReadInt16));
case GpType.Long:
return(new ReadDelegate(GpBinaryByteReader.ReadInt64));
case GpType.IntegerArray:
return(new ReadDelegate(GpBinaryByteReader.ReadIntArray));
case GpType.Boolean:
return(new ReadDelegate(GpBinaryByteReader.ReadBool));
case GpType.String:
return(new ReadDelegate(GpBinaryByteReader.ReadString));
case GpType.Vector:
return(new ReadDelegate(GpBinaryByteReader.ReadVector));
case GpType.ByteArray:
return(new ReadDelegate(GpBinaryByteReader.ReadByteArray));
case GpType.Array:
return(new ReadDelegate(GpBinaryByteReader.ReadArray));
case GpType.ObjectArray:
return(new ReadDelegate(GpBinaryByteReader.ReadObjectArray));
case GpType.Dictionary:
return(new ReadDelegate(GpBinaryByteReader.ReadDictionary));
}
return(null);
}
private static Type DeserializeDictionaryType(MemoryStream reader, out byte keyTypeCode, out byte valTypeCode)
{
keyTypeCode = (byte)reader.ReadByte();
valTypeCode = (byte)reader.ReadByte();
GpType gpType1 = (GpType)keyTypeCode;
GpType gpType2 = (GpType)valTypeCode;
return(typeof(Dictionary <,>).MakeGenericType(gpType1 != GpType.Unknown ? Protocol.GetTypeOfCode(keyTypeCode) : typeof(object), gpType2 != GpType.Unknown ? Protocol.GetTypeOfCode(valTypeCode) : typeof(object)));
}
private Type DeserializeDictionaryType(StreamBuffer reader, out byte keyTypeCode, out byte valTypeCode)
{
keyTypeCode = reader.ReadByte();
valTypeCode = reader.ReadByte();
GpType gpType = (GpType)keyTypeCode;
GpType gpType2 = (GpType)valTypeCode;
Type type = (gpType != 0) ? this.GetTypeOfCode(keyTypeCode) : typeof(object);
Type type2 = (gpType2 != 0) ? this.GetTypeOfCode(valTypeCode) : typeof(object);
return(typeof(Dictionary <,>).MakeGenericType(type, type2));
}
/// <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);
}
}
}
}
/// <summary>
/// The get clr array type.
/// </summary>
/// <param name="gpType">The gp type.</param>
/// <returns>the gpType</returns>
public static Type GetClrArrayType(GpType gpType)
{
switch (gpType)
{
case GpType.Byte:
return(typeof(byte));
case GpType.Double:
return(typeof(double));
case GpType.EventData:
return(typeof(EventData));
case GpType.Float:
return(typeof(float));
case GpType.Hashtable:
return(typeof(Hashtable));
case GpType.Integer:
return(typeof(int));
case GpType.Short:
return(typeof(short));
case GpType.Long:
return(typeof(long));
case GpType.Boolean:
return(typeof(bool));
case GpType.OperationResponse:
return(typeof(OperationResponse));
case GpType.OperationRequest:
return(typeof(OperationRequest));
case GpType.String:
return(typeof(string));
case GpType.Vector:
return(typeof(ArrayList));
case GpType.ByteArray:
return(typeof(byte[]));
}
return(null);
}
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);
}
private static void SerializeDictionaryHeader(MemoryStream writer, object dict, out bool setKeyType, out bool setValueType)
{
Type[] types = dict.GetType().GetGenericArguments();
setKeyType = types[0] == typeof(object);
setValueType = types[1] == typeof(object);
if (setKeyType)
{
writer.WriteByte(0);
}
else
{
GpType keyType = (GpType)GetCodeOfType(types[0]);
switch (keyType)
{
case GpType.Unknown:
case GpType.Dictionary:
throw new Exception("Unexpected - cannot serialize Dictionary with key type: " + types[0]);
}
writer.WriteByte((byte)keyType);
}
if (setValueType)
{
writer.WriteByte(0);
}
else
{
GpType valueType = (GpType)GetCodeOfType(types[1]);
if (valueType == GpType.Unknown)
{
throw new Exception("Unexpected - cannot serialize Dictionary with value type: " + types[0]);
}
writer.WriteByte((byte)valueType);
if (valueType == GpType.Dictionary)
{
SerializeDictionaryHeader(writer, types[1]);
}
}
}
private void SerializeDictionaryHeader(StreamBuffer writer, object dict, out bool setKeyType, out bool setValueType)
{
Type[] genericArguments = dict.GetType().GetGenericArguments();
setKeyType = (genericArguments[0] == typeof(object));
setValueType = (genericArguments[1] == typeof(object));
if (setKeyType)
{
writer.WriteByte(0);
}
else
{
GpType codeOfType = this.GetCodeOfType(genericArguments[0]);
if (codeOfType == GpType.Unknown || codeOfType == GpType.Dictionary)
{
throw new Exception("Unexpected - cannot serialize Dictionary with key type: " + genericArguments[0]);
}
writer.WriteByte((byte)codeOfType);
}
if (setValueType)
{
writer.WriteByte(0);
}
else
{
GpType codeOfType2 = this.GetCodeOfType(genericArguments[1]);
if (codeOfType2 == GpType.Unknown)
{
throw new Exception("Unexpected - cannot serialize Dictionary with value type: " + genericArguments[0]);
}
writer.WriteByte((byte)codeOfType2);
if (codeOfType2 == GpType.Dictionary)
{
this.SerializeDictionaryHeader(writer, genericArguments[1]);
}
}
}
private static void SerializeDictionaryHeader(MemoryStream writer, object dict, out bool setKeyType, out bool setValueType)
{
Type[] genericArguments = dict.GetType().GetGenericArguments();
setKeyType = genericArguments[0] == typeof(object);
setValueType = genericArguments[1] == typeof(object);
if (setKeyType)
{
writer.WriteByte((byte)0);
}
else
{
GpType codeOfType = (GpType)Protocol.GetCodeOfType(genericArguments[0]);
if (codeOfType == GpType.Unknown || codeOfType == GpType.Dictionary)
{
throw new Exception("Unexpected - cannot serialize Dictionary with key type: " + (object)genericArguments[0]);
}
writer.WriteByte((byte)codeOfType);
}
if (setValueType)
{
writer.WriteByte((byte)0);
}
else
{
GpType codeOfType = (GpType)Protocol.GetCodeOfType(genericArguments[1]);
if (codeOfType == GpType.Unknown)
{
throw new Exception("Unexpected - cannot serialize Dictionary with value type: " + (object)genericArguments[0]);
}
writer.WriteByte((byte)codeOfType);
if (codeOfType == GpType.Dictionary)
{
Protocol.SerializeDictionaryHeader(writer, genericArguments[1]);
}
}
}
private void SerializeArray(StreamBuffer dout, Array serObject, bool setType)
{
if (setType)
{
dout.WriteByte(121);
}
if (serObject.Length > 32767)
{
throw new NotSupportedException("String[] that exceed 32767 (short.MaxValue) entries are not supported. Yours is: " + serObject.Length);
}
this.SerializeShort(dout, (short)serObject.Length, false);
Type elementType = serObject.GetType().GetElementType();
GpType codeOfType = this.GetCodeOfType(elementType);
if (codeOfType != 0)
{
dout.WriteByte((byte)codeOfType);
if (codeOfType == GpType.Dictionary)
{
bool setKeyType = default(bool);
bool setValueType = default(bool);
this.SerializeDictionaryHeader(dout, (object)serObject, out setKeyType, out setValueType);
for (int i = 0; i < serObject.Length; i++)
{
object value = serObject.GetValue(i);
this.SerializeDictionaryElements(dout, value, setKeyType, setValueType);
}
}
else
{
for (int j = 0; j < serObject.Length; j++)
{
object value2 = serObject.GetValue(j);
this.Serialize(dout, value2, false);
}
}
return;
}
CustomType customType = default(CustomType);
if (Protocol.TypeDict.TryGetValue(elementType, out customType))
{
dout.WriteByte(99);
dout.WriteByte(customType.Code);
int num = 0;
short num2;
long num3;
while (true)
{
if (num < serObject.Length)
{
object value3 = serObject.GetValue(num);
if (customType.SerializeStreamFunction == null)
{
byte[] array = customType.SerializeFunction(value3);
this.SerializeShort(dout, (short)array.Length, false);
dout.Write(array, 0, array.Length);
}
else
{
int position = dout.Position;
dout.Position += 2;
num2 = customType.SerializeStreamFunction(dout, value3);
num3 = dout.Position;
dout.Position = position;
this.SerializeShort(dout, num2, false);
dout.Position += num2;
if (dout.Position != num3)
{
break;
}
}
num++;
continue;
}
return;
}
throw new Exception("Serialization failed. Stream position corrupted. Should be " + num3 + " is now: " + dout.Position + " serializedLength: " + num2);
}
throw new NotSupportedException("cannot serialize array of type " + elementType);
}
/// <summary>
/// Reads an object from a binary reader.
/// </summary>
/// <param name="binaryReader">The binary Reader.</param>
/// <param name="result">The result.</param>
/// <returns>The next object read from the binary reader.</returns>
public static bool Read(IBinaryReader binaryReader, out object result)
{
GpType protocolType = (GpType)binaryReader.ReadByte();
return(Read(binaryReader, protocolType, out result));
}
/// <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);
}
/// <summary>
/// The read.
/// </summary>
/// <param name="binaryReader"> The binary reader.</param>
/// <param name="protocolType">The protocol type.</param>
/// <param name="result"> The result.</param>
/// <returns>error 1 or ok</returns>
private static bool Read(IBinaryReader binaryReader, GpType protocolType, out object result)
{
switch (protocolType)
{
case GpType.StringArray:
return(ReadStringArray(binaryReader, out result));
case GpType.Byte:
return(ReadByte(binaryReader, out result));
case GpType.Custom:
return(ReadCustomType(binaryReader, out result));
case GpType.Double:
return(ReadDouble(binaryReader, out result));
case GpType.EventData:
return(ReadEventData(binaryReader, out result));
case GpType.Float:
return(ReadSingle(binaryReader, out result));
case GpType.Hashtable:
return(ReadHashTable(binaryReader, out result));
case GpType.Integer:
return(ReadInt32(binaryReader, out result));
case GpType.Short:
return(ReadInt16(binaryReader, out result));
case GpType.Long:
return(ReadInt64(binaryReader, out result));
case GpType.IntegerArray:
return(ReadIntArray(binaryReader, out result));
case GpType.Boolean:
return(ReadBool(binaryReader, out result));
case GpType.OperationResponse:
return(ReadOperationResponse(binaryReader, out result));
case GpType.OperationRequest:
return(ReadOperationRequest(binaryReader, out result));
case GpType.String:
return(ReadString(binaryReader, out result));
case GpType.Vector:
return(ReadVector(binaryReader, out result));
case GpType.ByteArray:
return(ReadByteArray(binaryReader, out result));
case GpType.Array:
return(ReadArray(binaryReader, out result));
case GpType.ObjectArray:
return(ReadObjectArray(binaryReader, out result));
case GpType.Dictionary:
return(ReadDictionary(binaryReader, out result));
case GpType.Null:
result = null;
return(true);
}
if (log.IsDebugEnabled)
{
log.DebugFormat("Unknown GpType {0} at position {1} at {2}", new object[] { protocolType, binaryReader.BaseStream.Position, new StackTrace(true) });
}
result = null;
return(false);
}
/// <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);
}
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);
}
private object ReadCustomTypeArray(StreamBuffer stream) => default; // 0x0000000180A06A20-0x0000000180A06C60
private Type ReadDictionaryType(StreamBuffer stream, out GpType keyReadType, out GpType valueReadType)
{
keyReadType = default;
valueReadType = default;
return(default);
private static Type GetAllowedDictionaryKeyTypes(GpType gpType) => default; // 0x0000000180A054A0-0x0000000180A05600 private static Type GetClrArrayType(GpType gpType) => default; // 0x0000000180A05600-0x0000000180A05800
public override byte DeserializeByte(StreamBuffer din) => default; // 0x00000001809FEDD0-0x00000001809FEDF0 private static Type GetAllowedDictionaryKeyTypes(GpType gpType) => default; // 0x0000000180A054A0-0x0000000180A05600
