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