scripts
This commit is contained in:
niko
@@ -0,0 +1,1444 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Text;
|
||||
|
||||
namespace ExitGames.Client.Photon
|
||||
{
|
||||
// Token: 0x02000028 RID: 40
|
||||
public class Protocol16 : IProtocol
|
||||
{
|
||||
// Token: 0x17000069 RID: 105
|
||||
// (get) Token: 0x060001D7 RID: 471 RVA: 0x0000F738 File Offset: 0x0000D938
|
||||
internal override string protocolType
|
||||
{
|
||||
get
|
||||
{
|
||||
return "GpBinaryV16";
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x1700006A RID: 106
|
||||
// (get) Token: 0x060001D8 RID: 472 RVA: 0x0000F750 File Offset: 0x0000D950
|
||||
internal override byte[] VersionBytes
|
||||
{
|
||||
get
|
||||
{
|
||||
return this.versionBytes;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001D9 RID: 473 RVA: 0x0000F768 File Offset: 0x0000D968
|
||||
private bool SerializeCustom(StreamBuffer dout, object serObject)
|
||||
{
|
||||
CustomType customType;
|
||||
bool flag = Protocol.TypeDict.TryGetValue(serObject.GetType(), out customType);
|
||||
bool flag3;
|
||||
if (flag)
|
||||
{
|
||||
bool flag2 = customType.SerializeStreamFunction == null;
|
||||
if (flag2)
|
||||
{
|
||||
byte[] array = customType.SerializeFunction(serObject);
|
||||
dout.WriteByte(99);
|
||||
dout.WriteByte(customType.Code);
|
||||
this.SerializeShort(dout, (short)array.Length, false);
|
||||
dout.Write(array, 0, array.Length);
|
||||
flag3 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
dout.WriteByte(99);
|
||||
dout.WriteByte(customType.Code);
|
||||
long position = dout.Position;
|
||||
dout.Position += 2L;
|
||||
short num = customType.SerializeStreamFunction(dout, serObject);
|
||||
long position2 = dout.Position;
|
||||
dout.Position = position;
|
||||
this.SerializeShort(dout, num, false);
|
||||
dout.Position += (long)num;
|
||||
bool flag4 = dout.Position != position2;
|
||||
if (flag4)
|
||||
{
|
||||
throw new Exception(string.Concat(new object[] { "Serialization failed. Stream position corrupted. Should be ", position2, " is now: ", dout.Position, " serializedLength: ", num }));
|
||||
}
|
||||
flag3 = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
flag3 = false;
|
||||
}
|
||||
return flag3;
|
||||
}
|
||||
|
||||
// Token: 0x060001DA RID: 474 RVA: 0x0000F8B8 File Offset: 0x0000DAB8
|
||||
private object DeserializeCustom(StreamBuffer din, byte customTypeCode)
|
||||
{
|
||||
short num = this.DeserializeShort(din);
|
||||
CustomType customType;
|
||||
bool flag = Protocol.CodeDict.TryGetValue(customTypeCode, out customType);
|
||||
object obj;
|
||||
if (flag)
|
||||
{
|
||||
bool flag2 = customType.DeserializeStreamFunction == null;
|
||||
if (flag2)
|
||||
{
|
||||
byte[] array = new byte[(int)num];
|
||||
din.Read(array, 0, (int)num);
|
||||
obj = customType.DeserializeFunction(array);
|
||||
}
|
||||
else
|
||||
{
|
||||
long position = din.Position;
|
||||
object obj2 = customType.DeserializeStreamFunction(din, num);
|
||||
int num2 = (int)(din.Position - position);
|
||||
bool flag3 = num2 != (int)num;
|
||||
if (flag3)
|
||||
{
|
||||
din.Position = position + (long)num;
|
||||
}
|
||||
obj = obj2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
byte[] array2 = new byte[(int)num];
|
||||
din.Read(array2, 0, (int)num);
|
||||
obj = array2;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
// Token: 0x060001DB RID: 475 RVA: 0x0000F974 File Offset: 0x0000DB74
|
||||
private Type GetTypeOfCode(byte typeCode)
|
||||
{
|
||||
if (typeCode <= 42)
|
||||
{
|
||||
if (typeCode == 0 || typeCode == 42)
|
||||
{
|
||||
return typeof(object);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (typeCode == 68)
|
||||
{
|
||||
return typeof(IDictionary);
|
||||
}
|
||||
switch (typeCode)
|
||||
{
|
||||
case 97:
|
||||
return typeof(string[]);
|
||||
case 98:
|
||||
return typeof(byte);
|
||||
case 99:
|
||||
return typeof(CustomType);
|
||||
case 100:
|
||||
return typeof(double);
|
||||
case 101:
|
||||
return typeof(EventData);
|
||||
case 102:
|
||||
return typeof(float);
|
||||
case 104:
|
||||
return typeof(Hashtable);
|
||||
case 105:
|
||||
return typeof(int);
|
||||
case 107:
|
||||
return typeof(short);
|
||||
case 108:
|
||||
return typeof(long);
|
||||
case 110:
|
||||
return typeof(int[]);
|
||||
case 111:
|
||||
return typeof(bool);
|
||||
case 112:
|
||||
return typeof(OperationResponse);
|
||||
case 113:
|
||||
return typeof(OperationRequest);
|
||||
case 115:
|
||||
return typeof(string);
|
||||
case 120:
|
||||
return typeof(byte[]);
|
||||
case 121:
|
||||
return typeof(Array);
|
||||
case 122:
|
||||
return typeof(object[]);
|
||||
}
|
||||
}
|
||||
Debug.WriteLine("missing type: " + typeCode);
|
||||
throw new Exception("deserialize(): " + typeCode);
|
||||
}
|
||||
|
||||
// Token: 0x060001DC RID: 476 RVA: 0x0000FB78 File Offset: 0x0000DD78
|
||||
private Protocol16.GpType GetCodeOfType(Type type)
|
||||
{
|
||||
TypeCode typeCode = Type.GetTypeCode(type);
|
||||
TypeCode typeCode2 = typeCode;
|
||||
switch (typeCode2)
|
||||
{
|
||||
case TypeCode.Boolean:
|
||||
return Protocol16.GpType.Boolean;
|
||||
case TypeCode.Char:
|
||||
case TypeCode.SByte:
|
||||
case TypeCode.UInt16:
|
||||
case TypeCode.UInt32:
|
||||
case TypeCode.UInt64:
|
||||
break;
|
||||
case TypeCode.Byte:
|
||||
return Protocol16.GpType.Byte;
|
||||
case TypeCode.Int16:
|
||||
return Protocol16.GpType.Short;
|
||||
case TypeCode.Int32:
|
||||
return Protocol16.GpType.Integer;
|
||||
case TypeCode.Int64:
|
||||
return Protocol16.GpType.Long;
|
||||
case TypeCode.Single:
|
||||
return Protocol16.GpType.Float;
|
||||
case TypeCode.Double:
|
||||
return Protocol16.GpType.Double;
|
||||
default:
|
||||
if (typeCode2 == TypeCode.String)
|
||||
{
|
||||
return Protocol16.GpType.String;
|
||||
}
|
||||
break;
|
||||
}
|
||||
bool isArray = type.IsArray;
|
||||
Protocol16.GpType gpType;
|
||||
if (isArray)
|
||||
{
|
||||
bool flag = type == typeof(byte[]);
|
||||
if (flag)
|
||||
{
|
||||
gpType = Protocol16.GpType.ByteArray;
|
||||
}
|
||||
else
|
||||
{
|
||||
gpType = Protocol16.GpType.Array;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag2 = type == typeof(Hashtable);
|
||||
if (flag2)
|
||||
{
|
||||
gpType = Protocol16.GpType.Hashtable;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag3 = type.IsGenericType && typeof(Dictionary<, >) == type.GetGenericTypeDefinition();
|
||||
if (flag3)
|
||||
{
|
||||
gpType = Protocol16.GpType.Dictionary;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag4 = type == typeof(EventData);
|
||||
if (flag4)
|
||||
{
|
||||
gpType = Protocol16.GpType.EventData;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag5 = type == typeof(OperationRequest);
|
||||
if (flag5)
|
||||
{
|
||||
gpType = Protocol16.GpType.OperationRequest;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag6 = type == typeof(OperationResponse);
|
||||
if (flag6)
|
||||
{
|
||||
gpType = Protocol16.GpType.OperationResponse;
|
||||
}
|
||||
else
|
||||
{
|
||||
gpType = Protocol16.GpType.Unknown;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return gpType;
|
||||
}
|
||||
|
||||
// Token: 0x060001DD RID: 477 RVA: 0x0000FCD4 File Offset: 0x0000DED4
|
||||
private Array CreateArrayByType(byte arrayType, short length)
|
||||
{
|
||||
return Array.CreateInstance(this.GetTypeOfCode(arrayType), (int)length);
|
||||
}
|
||||
|
||||
// Token: 0x060001DE RID: 478 RVA: 0x0000FCF3 File Offset: 0x0000DEF3
|
||||
private void SerializeOperationRequest(StreamBuffer stream, OperationRequest serObject, bool setType)
|
||||
{
|
||||
this.SerializeOperationRequest(stream, serObject.OperationCode, serObject.Parameters, setType);
|
||||
}
|
||||
|
||||
// Token: 0x060001DF RID: 479 RVA: 0x0000FD0C File Offset: 0x0000DF0C
|
||||
public override void SerializeOperationRequest(StreamBuffer stream, byte operationCode, Dictionary<byte, object> parameters, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
stream.WriteByte(113);
|
||||
}
|
||||
stream.WriteByte(operationCode);
|
||||
this.SerializeParameterTable(stream, parameters);
|
||||
}
|
||||
|
||||
// Token: 0x060001E0 RID: 480 RVA: 0x0000FD3C File Offset: 0x0000DF3C
|
||||
public override OperationRequest DeserializeOperationRequest(StreamBuffer din)
|
||||
{
|
||||
return new OperationRequest
|
||||
{
|
||||
OperationCode = this.DeserializeByte(din),
|
||||
Parameters = this.DeserializeParameterTable(din)
|
||||
};
|
||||
}
|
||||
|
||||
// Token: 0x060001E1 RID: 481 RVA: 0x0000FD70 File Offset: 0x0000DF70
|
||||
public override void SerializeOperationResponse(StreamBuffer stream, OperationResponse serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
stream.WriteByte(112);
|
||||
}
|
||||
stream.WriteByte(serObject.OperationCode);
|
||||
this.SerializeShort(stream, serObject.ReturnCode, false);
|
||||
bool flag = string.IsNullOrEmpty(serObject.DebugMessage);
|
||||
if (flag)
|
||||
{
|
||||
stream.WriteByte(42);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.SerializeString(stream, serObject.DebugMessage, false);
|
||||
}
|
||||
this.SerializeParameterTable(stream, serObject.Parameters);
|
||||
}
|
||||
|
||||
// Token: 0x060001E2 RID: 482 RVA: 0x0000FDE8 File Offset: 0x0000DFE8
|
||||
public override OperationResponse DeserializeOperationResponse(StreamBuffer stream)
|
||||
{
|
||||
return new OperationResponse
|
||||
{
|
||||
OperationCode = this.DeserializeByte(stream),
|
||||
ReturnCode = this.DeserializeShort(stream),
|
||||
DebugMessage = (this.Deserialize(stream, this.DeserializeByte(stream)) as string),
|
||||
Parameters = this.DeserializeParameterTable(stream)
|
||||
};
|
||||
}
|
||||
|
||||
// Token: 0x060001E3 RID: 483 RVA: 0x0000FE44 File Offset: 0x0000E044
|
||||
public override void SerializeEventData(StreamBuffer stream, EventData serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
stream.WriteByte(101);
|
||||
}
|
||||
stream.WriteByte(serObject.Code);
|
||||
this.SerializeParameterTable(stream, serObject.Parameters);
|
||||
}
|
||||
|
||||
// Token: 0x060001E4 RID: 484 RVA: 0x0000FE80 File Offset: 0x0000E080
|
||||
public override EventData DeserializeEventData(StreamBuffer din)
|
||||
{
|
||||
return new EventData
|
||||
{
|
||||
Code = this.DeserializeByte(din),
|
||||
Parameters = this.DeserializeParameterTable(din)
|
||||
};
|
||||
}
|
||||
|
||||
// Token: 0x060001E5 RID: 485 RVA: 0x0000FEB4 File Offset: 0x0000E0B4
|
||||
private void SerializeParameterTable(StreamBuffer stream, Dictionary<byte, object> parameters)
|
||||
{
|
||||
bool flag = parameters == null || parameters.Count == 0;
|
||||
if (flag)
|
||||
{
|
||||
this.SerializeShort(stream, 0, false);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.SerializeShort(stream, (short)parameters.Count, false);
|
||||
foreach (KeyValuePair<byte, object> keyValuePair in parameters)
|
||||
{
|
||||
stream.WriteByte(keyValuePair.Key);
|
||||
this.Serialize(stream, keyValuePair.Value, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001E6 RID: 486 RVA: 0x0000FF50 File Offset: 0x0000E150
|
||||
private Dictionary<byte, object> DeserializeParameterTable(StreamBuffer stream)
|
||||
{
|
||||
short num = this.DeserializeShort(stream);
|
||||
Dictionary<byte, object> dictionary = new Dictionary<byte, object>((int)num);
|
||||
for (int i = 0; i < (int)num; i++)
|
||||
{
|
||||
byte b = (byte)stream.ReadByte();
|
||||
object obj = this.Deserialize(stream, (byte)stream.ReadByte());
|
||||
dictionary[b] = obj;
|
||||
}
|
||||
return dictionary;
|
||||
}
|
||||
|
||||
// Token: 0x060001E7 RID: 487 RVA: 0x0000FFAC File Offset: 0x0000E1AC
|
||||
public override void Serialize(StreamBuffer dout, object serObject, bool setType)
|
||||
{
|
||||
bool flag = serObject == null;
|
||||
if (flag)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(42);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Protocol16.GpType codeOfType = this.GetCodeOfType(serObject.GetType());
|
||||
Protocol16.GpType gpType = codeOfType;
|
||||
if (gpType != Protocol16.GpType.Dictionary)
|
||||
{
|
||||
switch (gpType)
|
||||
{
|
||||
case Protocol16.GpType.Byte:
|
||||
this.SerializeByte(dout, (byte)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Double:
|
||||
this.SerializeDouble(dout, (double)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.EventData:
|
||||
this.SerializeEventData(dout, (EventData)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Float:
|
||||
this.SerializeFloat(dout, (float)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Hashtable:
|
||||
this.SerializeHashTable(dout, (Hashtable)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Integer:
|
||||
this.SerializeInteger(dout, (int)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Short:
|
||||
this.SerializeShort(dout, (short)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Long:
|
||||
this.SerializeLong(dout, (long)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Boolean:
|
||||
this.SerializeBoolean(dout, (bool)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.OperationResponse:
|
||||
this.SerializeOperationResponse(dout, (OperationResponse)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.OperationRequest:
|
||||
this.SerializeOperationRequest(dout, (OperationRequest)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.String:
|
||||
this.SerializeString(dout, (string)serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.ByteArray:
|
||||
this.SerializeByteArray(dout, (byte[])serObject, setType);
|
||||
return;
|
||||
case Protocol16.GpType.Array:
|
||||
{
|
||||
bool flag2 = serObject is int[];
|
||||
if (flag2)
|
||||
{
|
||||
this.SerializeIntArrayOptimized(dout, (int[])serObject, setType);
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag3 = serObject.GetType().GetElementType() == typeof(object);
|
||||
if (flag3)
|
||||
{
|
||||
this.SerializeObjectArray(dout, serObject as object[], setType);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.SerializeArray(dout, (Array)serObject, setType);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
bool flag4 = serObject is ArraySegment<byte>;
|
||||
if (flag4)
|
||||
{
|
||||
ArraySegment<byte> arraySegment = (ArraySegment<byte>)serObject;
|
||||
this.SerializeByteArraySegment(dout, arraySegment.Array, arraySegment.Offset, arraySegment.Count, setType);
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag5 = !this.SerializeCustom(dout, serObject);
|
||||
if (flag5)
|
||||
{
|
||||
throw new Exception("cannot serialize(): " + serObject.GetType());
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
this.SerializeDictionary(dout, (IDictionary)serObject, setType);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001E8 RID: 488 RVA: 0x0001023C File Offset: 0x0000E43C
|
||||
private void SerializeByte(StreamBuffer dout, byte serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(98);
|
||||
}
|
||||
dout.WriteByte(serObject);
|
||||
}
|
||||
|
||||
// Token: 0x060001E9 RID: 489 RVA: 0x00010264 File Offset: 0x0000E464
|
||||
private void SerializeBoolean(StreamBuffer dout, bool serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(111);
|
||||
}
|
||||
dout.WriteByte(serObject ? 1 : 0);
|
||||
}
|
||||
|
||||
// Token: 0x060001EA RID: 490 RVA: 0x00010290 File Offset: 0x0000E490
|
||||
public override void SerializeShort(StreamBuffer dout, short serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(107);
|
||||
}
|
||||
byte[] array = this.memShort;
|
||||
lock (array)
|
||||
{
|
||||
byte[] array2 = this.memShort;
|
||||
array2[0] = (byte)(serObject >> 8);
|
||||
array2[1] = (byte)serObject;
|
||||
dout.Write(array2, 0, 2);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001EB RID: 491 RVA: 0x000102F8 File Offset: 0x0000E4F8
|
||||
private void SerializeInteger(StreamBuffer dout, int serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(105);
|
||||
}
|
||||
byte[] array = this.memInteger;
|
||||
lock (array)
|
||||
{
|
||||
byte[] array2 = this.memInteger;
|
||||
array2[0] = (byte)(serObject >> 24);
|
||||
array2[1] = (byte)(serObject >> 16);
|
||||
array2[2] = (byte)(serObject >> 8);
|
||||
array2[3] = (byte)serObject;
|
||||
dout.Write(array2, 0, 4);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001EC RID: 492 RVA: 0x00010370 File Offset: 0x0000E570
|
||||
private void SerializeLong(StreamBuffer dout, long serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(108);
|
||||
}
|
||||
long[] array = this.memLongBlock;
|
||||
lock (array)
|
||||
{
|
||||
this.memLongBlock[0] = serObject;
|
||||
Buffer.BlockCopy(this.memLongBlock, 0, this.memLongBlockBytes, 0, 8);
|
||||
byte[] array2 = this.memLongBlockBytes;
|
||||
bool isLittleEndian = BitConverter.IsLittleEndian;
|
||||
if (isLittleEndian)
|
||||
{
|
||||
byte b = array2[0];
|
||||
byte b2 = array2[1];
|
||||
byte b3 = array2[2];
|
||||
byte b4 = array2[3];
|
||||
array2[0] = array2[7];
|
||||
array2[1] = array2[6];
|
||||
array2[2] = array2[5];
|
||||
array2[3] = array2[4];
|
||||
array2[4] = b4;
|
||||
array2[5] = b3;
|
||||
array2[6] = b2;
|
||||
array2[7] = b;
|
||||
}
|
||||
dout.Write(array2, 0, 8);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001ED RID: 493 RVA: 0x00010434 File Offset: 0x0000E634
|
||||
private void SerializeFloat(StreamBuffer dout, float serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(102);
|
||||
}
|
||||
byte[] array = Protocol16.memFloatBlockBytes;
|
||||
lock (array)
|
||||
{
|
||||
Protocol16.memFloatBlock[0] = serObject;
|
||||
Buffer.BlockCopy(Protocol16.memFloatBlock, 0, Protocol16.memFloatBlockBytes, 0, 4);
|
||||
bool isLittleEndian = BitConverter.IsLittleEndian;
|
||||
if (isLittleEndian)
|
||||
{
|
||||
byte b = Protocol16.memFloatBlockBytes[0];
|
||||
byte b2 = Protocol16.memFloatBlockBytes[1];
|
||||
Protocol16.memFloatBlockBytes[0] = Protocol16.memFloatBlockBytes[3];
|
||||
Protocol16.memFloatBlockBytes[1] = Protocol16.memFloatBlockBytes[2];
|
||||
Protocol16.memFloatBlockBytes[2] = b2;
|
||||
Protocol16.memFloatBlockBytes[3] = b;
|
||||
}
|
||||
dout.Write(Protocol16.memFloatBlockBytes, 0, 4);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001EE RID: 494 RVA: 0x000104F0 File Offset: 0x0000E6F0
|
||||
private void SerializeDouble(StreamBuffer dout, double serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(100);
|
||||
}
|
||||
byte[] array = this.memDoubleBlockBytes;
|
||||
lock (array)
|
||||
{
|
||||
this.memDoubleBlock[0] = serObject;
|
||||
Buffer.BlockCopy(this.memDoubleBlock, 0, this.memDoubleBlockBytes, 0, 8);
|
||||
byte[] array2 = this.memDoubleBlockBytes;
|
||||
bool isLittleEndian = BitConverter.IsLittleEndian;
|
||||
if (isLittleEndian)
|
||||
{
|
||||
byte b = array2[0];
|
||||
byte b2 = array2[1];
|
||||
byte b3 = array2[2];
|
||||
byte b4 = array2[3];
|
||||
array2[0] = array2[7];
|
||||
array2[1] = array2[6];
|
||||
array2[2] = array2[5];
|
||||
array2[3] = array2[4];
|
||||
array2[4] = b4;
|
||||
array2[5] = b3;
|
||||
array2[6] = b2;
|
||||
array2[7] = b;
|
||||
}
|
||||
dout.Write(array2, 0, 8);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001EF RID: 495 RVA: 0x000105B4 File Offset: 0x0000E7B4
|
||||
public override void SerializeString(StreamBuffer dout, string serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(115);
|
||||
}
|
||||
byte[] bytes = Encoding.UTF8.GetBytes(serObject);
|
||||
bool flag = bytes.Length > 32767;
|
||||
if (flag)
|
||||
{
|
||||
throw new NotSupportedException("Strings that exceed a UTF8-encoded byte-length of 32767 (short.MaxValue) are not supported. Yours is: " + bytes.Length);
|
||||
}
|
||||
this.SerializeShort(dout, (short)bytes.Length, false);
|
||||
dout.Write(bytes, 0, bytes.Length);
|
||||
}
|
||||
|
||||
// Token: 0x060001F0 RID: 496 RVA: 0x00010620 File Offset: 0x0000E820
|
||||
private void SerializeArray(StreamBuffer dout, Array serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(121);
|
||||
}
|
||||
bool flag = serObject.Length > 32767;
|
||||
if (flag)
|
||||
{
|
||||
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();
|
||||
Protocol16.GpType codeOfType = this.GetCodeOfType(elementType);
|
||||
bool flag2 = codeOfType > Protocol16.GpType.Unknown;
|
||||
if (flag2)
|
||||
{
|
||||
dout.WriteByte((byte)codeOfType);
|
||||
bool flag3 = codeOfType == Protocol16.GpType.Dictionary;
|
||||
if (flag3)
|
||||
{
|
||||
bool flag4;
|
||||
bool flag5;
|
||||
this.SerializeDictionaryHeader(dout, serObject, out flag4, out flag5);
|
||||
for (int i = 0; i < serObject.Length; i++)
|
||||
{
|
||||
object value = serObject.GetValue(i);
|
||||
this.SerializeDictionaryElements(dout, value, flag4, flag5);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int j = 0; j < serObject.Length; j++)
|
||||
{
|
||||
object value2 = serObject.GetValue(j);
|
||||
this.Serialize(dout, value2, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
CustomType customType;
|
||||
bool flag6 = Protocol.TypeDict.TryGetValue(elementType, out customType);
|
||||
if (!flag6)
|
||||
{
|
||||
throw new NotSupportedException("cannot serialize array of type " + elementType);
|
||||
}
|
||||
dout.WriteByte(99);
|
||||
dout.WriteByte(customType.Code);
|
||||
for (int k = 0; k < serObject.Length; k++)
|
||||
{
|
||||
object value3 = serObject.GetValue(k);
|
||||
bool flag7 = customType.SerializeStreamFunction == null;
|
||||
if (flag7)
|
||||
{
|
||||
byte[] array = customType.SerializeFunction(value3);
|
||||
this.SerializeShort(dout, (short)array.Length, false);
|
||||
dout.Write(array, 0, array.Length);
|
||||
}
|
||||
else
|
||||
{
|
||||
long position = dout.Position;
|
||||
dout.Position += 2L;
|
||||
short num = customType.SerializeStreamFunction(dout, value3);
|
||||
long position2 = dout.Position;
|
||||
dout.Position = position;
|
||||
this.SerializeShort(dout, num, false);
|
||||
dout.Position += (long)num;
|
||||
bool flag8 = dout.Position != position2;
|
||||
if (flag8)
|
||||
{
|
||||
throw new Exception(string.Concat(new object[] { "Serialization failed. Stream position corrupted. Should be ", position2, " is now: ", dout.Position, " serializedLength: ", num }));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001F1 RID: 497 RVA: 0x0001089C File Offset: 0x0000EA9C
|
||||
private void SerializeByteArray(StreamBuffer dout, byte[] serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(120);
|
||||
}
|
||||
this.SerializeInteger(dout, serObject.Length, false);
|
||||
dout.Write(serObject, 0, serObject.Length);
|
||||
}
|
||||
|
||||
// Token: 0x060001F2 RID: 498 RVA: 0x000108D4 File Offset: 0x0000EAD4
|
||||
private void SerializeByteArraySegment(StreamBuffer dout, byte[] serObject, int offset, int count, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(120);
|
||||
}
|
||||
this.SerializeInteger(dout, count, false);
|
||||
dout.Write(serObject, offset, count);
|
||||
}
|
||||
|
||||
// Token: 0x060001F3 RID: 499 RVA: 0x0001090C File Offset: 0x0000EB0C
|
||||
private void SerializeIntArrayOptimized(StreamBuffer inWriter, int[] serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
inWriter.WriteByte(121);
|
||||
}
|
||||
this.SerializeShort(inWriter, (short)serObject.Length, false);
|
||||
inWriter.WriteByte(105);
|
||||
byte[] array = new byte[serObject.Length * 4];
|
||||
int num = 0;
|
||||
for (int i = 0; i < serObject.Length; i++)
|
||||
{
|
||||
array[num++] = (byte)(serObject[i] >> 24);
|
||||
array[num++] = (byte)(serObject[i] >> 16);
|
||||
array[num++] = (byte)(serObject[i] >> 8);
|
||||
array[num++] = (byte)serObject[i];
|
||||
}
|
||||
inWriter.Write(array, 0, array.Length);
|
||||
}
|
||||
|
||||
// Token: 0x060001F4 RID: 500 RVA: 0x000109A4 File Offset: 0x0000EBA4
|
||||
private void SerializeStringArray(StreamBuffer dout, string[] serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(97);
|
||||
}
|
||||
this.SerializeShort(dout, (short)serObject.Length, false);
|
||||
for (int i = 0; i < serObject.Length; i++)
|
||||
{
|
||||
this.SerializeString(dout, serObject[i], false);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001F5 RID: 501 RVA: 0x000109F0 File Offset: 0x0000EBF0
|
||||
private void SerializeObjectArray(StreamBuffer dout, object[] objects, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(122);
|
||||
}
|
||||
this.SerializeShort(dout, (short)objects.Length, false);
|
||||
foreach (object obj in objects)
|
||||
{
|
||||
this.Serialize(dout, obj, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001F6 RID: 502 RVA: 0x00010A40 File Offset: 0x0000EC40
|
||||
private void SerializeHashTable(StreamBuffer dout, Hashtable serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(104);
|
||||
}
|
||||
this.SerializeShort(dout, (short)serObject.Count, false);
|
||||
Dictionary<object, object>.KeyCollection keys = serObject.Keys;
|
||||
foreach (object obj in keys)
|
||||
{
|
||||
this.Serialize(dout, obj, true);
|
||||
this.Serialize(dout, serObject[obj], true);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001F7 RID: 503 RVA: 0x00010AD0 File Offset: 0x0000ECD0
|
||||
private void SerializeDictionary(StreamBuffer dout, IDictionary serObject, bool setType)
|
||||
{
|
||||
if (setType)
|
||||
{
|
||||
dout.WriteByte(68);
|
||||
}
|
||||
bool flag;
|
||||
bool flag2;
|
||||
this.SerializeDictionaryHeader(dout, serObject, out flag, out flag2);
|
||||
this.SerializeDictionaryElements(dout, serObject, flag, flag2);
|
||||
}
|
||||
|
||||
// Token: 0x060001F8 RID: 504 RVA: 0x00010B08 File Offset: 0x0000ED08
|
||||
private void SerializeDictionaryHeader(StreamBuffer writer, Type dictType)
|
||||
{
|
||||
bool flag;
|
||||
bool flag2;
|
||||
this.SerializeDictionaryHeader(writer, dictType, out flag, out flag2);
|
||||
}
|
||||
|
||||
// Token: 0x060001F9 RID: 505 RVA: 0x00010B24 File Offset: 0x0000ED24
|
||||
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);
|
||||
bool flag = setKeyType;
|
||||
if (flag)
|
||||
{
|
||||
writer.WriteByte(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
Protocol16.GpType codeOfType = this.GetCodeOfType(genericArguments[0]);
|
||||
bool flag2 = codeOfType == Protocol16.GpType.Unknown || codeOfType == Protocol16.GpType.Dictionary;
|
||||
if (flag2)
|
||||
{
|
||||
throw new Exception("Unexpected - cannot serialize Dictionary with key type: " + genericArguments[0]);
|
||||
}
|
||||
writer.WriteByte((byte)codeOfType);
|
||||
}
|
||||
bool flag3 = setValueType;
|
||||
if (flag3)
|
||||
{
|
||||
writer.WriteByte(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
Protocol16.GpType codeOfType2 = this.GetCodeOfType(genericArguments[1]);
|
||||
bool flag4 = codeOfType2 == Protocol16.GpType.Unknown;
|
||||
if (flag4)
|
||||
{
|
||||
throw new Exception("Unexpected - cannot serialize Dictionary with value type: " + genericArguments[0]);
|
||||
}
|
||||
writer.WriteByte((byte)codeOfType2);
|
||||
bool flag5 = codeOfType2 == Protocol16.GpType.Dictionary;
|
||||
if (flag5)
|
||||
{
|
||||
this.SerializeDictionaryHeader(writer, genericArguments[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001FA RID: 506 RVA: 0x00010C10 File Offset: 0x0000EE10
|
||||
private void SerializeDictionaryElements(StreamBuffer writer, object dict, bool setKeyType, bool setValueType)
|
||||
{
|
||||
IDictionary dictionary = (IDictionary)dict;
|
||||
this.SerializeShort(writer, (short)dictionary.Count, false);
|
||||
foreach (object obj in dictionary)
|
||||
{
|
||||
DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
|
||||
bool flag = !setValueType && dictionaryEntry.Value == null;
|
||||
if (flag)
|
||||
{
|
||||
throw new Exception("Can't serialize null in Dictionary with specific value-type.");
|
||||
}
|
||||
bool flag2 = !setKeyType && dictionaryEntry.Key == null;
|
||||
if (flag2)
|
||||
{
|
||||
throw new Exception("Can't serialize null in Dictionary with specific key-type.");
|
||||
}
|
||||
this.Serialize(writer, dictionaryEntry.Key, setKeyType);
|
||||
this.Serialize(writer, dictionaryEntry.Value, setValueType);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001FB RID: 507 RVA: 0x00010CE0 File Offset: 0x0000EEE0
|
||||
public override object Deserialize(StreamBuffer din, byte type)
|
||||
{
|
||||
if (type <= 42)
|
||||
{
|
||||
if (type == 0 || type == 42)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (type == 68)
|
||||
{
|
||||
return this.DeserializeDictionary(din);
|
||||
}
|
||||
switch (type)
|
||||
{
|
||||
case 97:
|
||||
return this.DeserializeStringArray(din);
|
||||
case 98:
|
||||
return this.DeserializeByte(din);
|
||||
case 99:
|
||||
{
|
||||
byte b = (byte)din.ReadByte();
|
||||
return this.DeserializeCustom(din, b);
|
||||
}
|
||||
case 100:
|
||||
return this.DeserializeDouble(din);
|
||||
case 101:
|
||||
return this.DeserializeEventData(din);
|
||||
case 102:
|
||||
return this.DeserializeFloat(din);
|
||||
case 104:
|
||||
return this.DeserializeHashTable(din);
|
||||
case 105:
|
||||
return this.DeserializeInteger(din);
|
||||
case 107:
|
||||
return this.DeserializeShort(din);
|
||||
case 108:
|
||||
return this.DeserializeLong(din);
|
||||
case 110:
|
||||
return this.DeserializeIntArray(din);
|
||||
case 111:
|
||||
return this.DeserializeBoolean(din);
|
||||
case 112:
|
||||
return this.DeserializeOperationResponse(din);
|
||||
case 113:
|
||||
return this.DeserializeOperationRequest(din);
|
||||
case 115:
|
||||
return this.DeserializeString(din);
|
||||
case 120:
|
||||
return this.DeserializeByteArray(din);
|
||||
case 121:
|
||||
return this.DeserializeArray(din);
|
||||
case 122:
|
||||
return this.DeserializeObjectArray(din);
|
||||
}
|
||||
}
|
||||
throw new Exception(string.Concat(new object[]
|
||||
{
|
||||
"Deserialize(): ",
|
||||
type,
|
||||
" pos: ",
|
||||
din.Position,
|
||||
" bytes: ",
|
||||
din.Length,
|
||||
". ",
|
||||
SupportClass.ByteArrayToString(din.GetBuffer())
|
||||
}));
|
||||
}
|
||||
|
||||
// Token: 0x060001FC RID: 508 RVA: 0x00010F10 File Offset: 0x0000F110
|
||||
public override byte DeserializeByte(StreamBuffer din)
|
||||
{
|
||||
return (byte)din.ReadByte();
|
||||
}
|
||||
|
||||
// Token: 0x060001FD RID: 509 RVA: 0x00010F2C File Offset: 0x0000F12C
|
||||
private bool DeserializeBoolean(StreamBuffer din)
|
||||
{
|
||||
return din.ReadByte() != 0;
|
||||
}
|
||||
|
||||
// Token: 0x060001FE RID: 510 RVA: 0x00010F48 File Offset: 0x0000F148
|
||||
public override short DeserializeShort(StreamBuffer din)
|
||||
{
|
||||
byte[] array = this.memShort;
|
||||
short num;
|
||||
lock (array)
|
||||
{
|
||||
byte[] array2 = this.memShort;
|
||||
din.Read(array2, 0, 2);
|
||||
num = (short)(((int)array2[0] << 8) | (int)array2[1]);
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x060001FF RID: 511 RVA: 0x00010F9C File Offset: 0x0000F19C
|
||||
private int DeserializeInteger(StreamBuffer din)
|
||||
{
|
||||
byte[] array = this.memInteger;
|
||||
int num;
|
||||
lock (array)
|
||||
{
|
||||
byte[] array2 = this.memInteger;
|
||||
din.Read(array2, 0, 4);
|
||||
num = ((int)array2[0] << 24) | ((int)array2[1] << 16) | ((int)array2[2] << 8) | (int)array2[3];
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x06000200 RID: 512 RVA: 0x00011000 File Offset: 0x0000F200
|
||||
private long DeserializeLong(StreamBuffer din)
|
||||
{
|
||||
byte[] array = this.memLong;
|
||||
long num;
|
||||
lock (array)
|
||||
{
|
||||
byte[] array2 = this.memLong;
|
||||
din.Read(array2, 0, 8);
|
||||
bool isLittleEndian = BitConverter.IsLittleEndian;
|
||||
if (isLittleEndian)
|
||||
{
|
||||
num = (long)(((ulong)array2[0] << 56) | ((ulong)array2[1] << 48) | ((ulong)array2[2] << 40) | ((ulong)array2[3] << 32) | ((ulong)array2[4] << 24) | ((ulong)array2[5] << 16) | ((ulong)array2[6] << 8) | (ulong)array2[7]);
|
||||
}
|
||||
else
|
||||
{
|
||||
num = BitConverter.ToInt64(array2, 0);
|
||||
}
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x06000201 RID: 513 RVA: 0x0001109C File Offset: 0x0000F29C
|
||||
private float DeserializeFloat(StreamBuffer din)
|
||||
{
|
||||
byte[] array = this.memFloat;
|
||||
float num;
|
||||
lock (array)
|
||||
{
|
||||
byte[] array2 = this.memFloat;
|
||||
din.Read(array2, 0, 4);
|
||||
bool isLittleEndian = BitConverter.IsLittleEndian;
|
||||
if (isLittleEndian)
|
||||
{
|
||||
byte b = array2[0];
|
||||
byte b2 = array2[1];
|
||||
array2[0] = array2[3];
|
||||
array2[1] = array2[2];
|
||||
array2[2] = b2;
|
||||
array2[3] = b;
|
||||
}
|
||||
num = BitConverter.ToSingle(array2, 0);
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x06000202 RID: 514 RVA: 0x00011118 File Offset: 0x0000F318
|
||||
private double DeserializeDouble(StreamBuffer din)
|
||||
{
|
||||
byte[] array = this.memDouble;
|
||||
double num;
|
||||
lock (array)
|
||||
{
|
||||
byte[] array2 = this.memDouble;
|
||||
din.Read(array2, 0, 8);
|
||||
bool isLittleEndian = BitConverter.IsLittleEndian;
|
||||
if (isLittleEndian)
|
||||
{
|
||||
byte b = array2[0];
|
||||
byte b2 = array2[1];
|
||||
byte b3 = array2[2];
|
||||
byte b4 = array2[3];
|
||||
array2[0] = array2[7];
|
||||
array2[1] = array2[6];
|
||||
array2[2] = array2[5];
|
||||
array2[3] = array2[4];
|
||||
array2[4] = b4;
|
||||
array2[5] = b3;
|
||||
array2[6] = b2;
|
||||
array2[7] = b;
|
||||
}
|
||||
num = BitConverter.ToDouble(array2, 0);
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x06000203 RID: 515 RVA: 0x000111B4 File Offset: 0x0000F3B4
|
||||
private string DeserializeString(StreamBuffer din)
|
||||
{
|
||||
short num = this.DeserializeShort(din);
|
||||
bool flag = num == 0;
|
||||
string text;
|
||||
if (flag)
|
||||
{
|
||||
text = string.Empty;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag2 = this.memString == null || this.memString.Length < (int)num;
|
||||
if (flag2)
|
||||
{
|
||||
this.memString = new byte[(int)num];
|
||||
}
|
||||
din.Read(this.memString, 0, (int)num);
|
||||
text = Encoding.UTF8.GetString(this.memString, 0, (int)num);
|
||||
}
|
||||
return text;
|
||||
}
|
||||
|
||||
// Token: 0x06000204 RID: 516 RVA: 0x00011228 File Offset: 0x0000F428
|
||||
private Array DeserializeArray(StreamBuffer din)
|
||||
{
|
||||
short num = this.DeserializeShort(din);
|
||||
byte b = (byte)din.ReadByte();
|
||||
bool flag = b == 121;
|
||||
Array array2;
|
||||
if (flag)
|
||||
{
|
||||
Array array = this.DeserializeArray(din);
|
||||
Type type = array.GetType();
|
||||
array2 = Array.CreateInstance(type, (int)num);
|
||||
array2.SetValue(array, 0);
|
||||
for (short num2 = 1; num2 < num; num2 += 1)
|
||||
{
|
||||
array = this.DeserializeArray(din);
|
||||
array2.SetValue(array, (int)num2);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag2 = b == 120;
|
||||
if (flag2)
|
||||
{
|
||||
array2 = Array.CreateInstance(typeof(byte[]), (int)num);
|
||||
for (short num3 = 0; num3 < num; num3 += 1)
|
||||
{
|
||||
Array array3 = this.DeserializeByteArray(din);
|
||||
array2.SetValue(array3, (int)num3);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag3 = b == 99;
|
||||
if (flag3)
|
||||
{
|
||||
byte b2 = (byte)din.ReadByte();
|
||||
CustomType customType;
|
||||
bool flag4 = Protocol.CodeDict.TryGetValue(b2, out customType);
|
||||
if (!flag4)
|
||||
{
|
||||
throw new Exception("Cannot find deserializer for custom type: " + b2);
|
||||
}
|
||||
array2 = Array.CreateInstance(customType.Type, (int)num);
|
||||
for (int i = 0; i < (int)num; i++)
|
||||
{
|
||||
short num4 = this.DeserializeShort(din);
|
||||
bool flag5 = customType.DeserializeStreamFunction == null;
|
||||
if (flag5)
|
||||
{
|
||||
byte[] array4 = new byte[(int)num4];
|
||||
din.Read(array4, 0, (int)num4);
|
||||
array2.SetValue(customType.DeserializeFunction(array4), i);
|
||||
}
|
||||
else
|
||||
{
|
||||
array2.SetValue(customType.DeserializeStreamFunction(din, num4), i);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool flag6 = b == 68;
|
||||
if (flag6)
|
||||
{
|
||||
Array array5 = null;
|
||||
this.DeserializeDictionaryArray(din, num, out array5);
|
||||
return array5;
|
||||
}
|
||||
array2 = this.CreateArrayByType(b, num);
|
||||
for (short num5 = 0; num5 < num; num5 += 1)
|
||||
{
|
||||
array2.SetValue(this.Deserialize(din, b), (int)num5);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return array2;
|
||||
}
|
||||
|
||||
// Token: 0x06000205 RID: 517 RVA: 0x0001142C File Offset: 0x0000F62C
|
||||
private byte[] DeserializeByteArray(StreamBuffer din)
|
||||
{
|
||||
int num = this.DeserializeInteger(din);
|
||||
byte[] array = new byte[num];
|
||||
din.Read(array, 0, num);
|
||||
return array;
|
||||
}
|
||||
|
||||
// Token: 0x06000206 RID: 518 RVA: 0x00011458 File Offset: 0x0000F658
|
||||
private int[] DeserializeIntArray(StreamBuffer din)
|
||||
{
|
||||
int num = this.DeserializeInteger(din);
|
||||
int[] array = new int[num];
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
array[i] = this.DeserializeInteger(din);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
// Token: 0x06000207 RID: 519 RVA: 0x00011498 File Offset: 0x0000F698
|
||||
private string[] DeserializeStringArray(StreamBuffer din)
|
||||
{
|
||||
int num = (int)this.DeserializeShort(din);
|
||||
string[] array = new string[num];
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
array[i] = this.DeserializeString(din);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
// Token: 0x06000208 RID: 520 RVA: 0x000114D8 File Offset: 0x0000F6D8
|
||||
private object[] DeserializeObjectArray(StreamBuffer din)
|
||||
{
|
||||
short num = this.DeserializeShort(din);
|
||||
object[] array = new object[(int)num];
|
||||
for (int i = 0; i < (int)num; i++)
|
||||
{
|
||||
byte b = (byte)din.ReadByte();
|
||||
array[i] = this.Deserialize(din, b);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
// Token: 0x06000209 RID: 521 RVA: 0x00011524 File Offset: 0x0000F724
|
||||
private Hashtable DeserializeHashTable(StreamBuffer din)
|
||||
{
|
||||
int num = (int)this.DeserializeShort(din);
|
||||
Hashtable hashtable = new Hashtable(num);
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
object obj = this.Deserialize(din, (byte)din.ReadByte());
|
||||
object obj2 = this.Deserialize(din, (byte)din.ReadByte());
|
||||
hashtable[obj] = obj2;
|
||||
}
|
||||
return hashtable;
|
||||
}
|
||||
|
||||
// Token: 0x0600020A RID: 522 RVA: 0x00011588 File Offset: 0x0000F788
|
||||
private IDictionary DeserializeDictionary(StreamBuffer din)
|
||||
{
|
||||
byte b = (byte)din.ReadByte();
|
||||
byte b2 = (byte)din.ReadByte();
|
||||
int num = (int)this.DeserializeShort(din);
|
||||
bool flag = b == 0 || b == 42;
|
||||
bool flag2 = b2 == 0 || b2 == 42;
|
||||
Type typeOfCode = this.GetTypeOfCode(b);
|
||||
Type typeOfCode2 = this.GetTypeOfCode(b2);
|
||||
Type type = typeof(Dictionary<, >).MakeGenericType(new Type[] { typeOfCode, typeOfCode2 });
|
||||
IDictionary dictionary = Activator.CreateInstance(type) as IDictionary;
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
object obj = this.Deserialize(din, flag ? ((byte)din.ReadByte()) : b);
|
||||
object obj2 = this.Deserialize(din, flag2 ? ((byte)din.ReadByte()) : b2);
|
||||
dictionary.Add(obj, obj2);
|
||||
}
|
||||
return dictionary;
|
||||
}
|
||||
|
||||
// Token: 0x0600020B RID: 523 RVA: 0x00011664 File Offset: 0x0000F864
|
||||
private bool DeserializeDictionaryArray(StreamBuffer din, short size, out Array arrayResult)
|
||||
{
|
||||
byte b;
|
||||
byte b2;
|
||||
Type type = this.DeserializeDictionaryType(din, out b, out b2);
|
||||
arrayResult = Array.CreateInstance(type, (int)size);
|
||||
for (short num = 0; num < size; num += 1)
|
||||
{
|
||||
IDictionary dictionary = Activator.CreateInstance(type) as IDictionary;
|
||||
bool flag = dictionary == null;
|
||||
if (flag)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
short num2 = this.DeserializeShort(din);
|
||||
for (int i = 0; i < (int)num2; i++)
|
||||
{
|
||||
bool flag2 = b > 0;
|
||||
object obj;
|
||||
if (flag2)
|
||||
{
|
||||
obj = this.Deserialize(din, b);
|
||||
}
|
||||
else
|
||||
{
|
||||
byte b3 = (byte)din.ReadByte();
|
||||
obj = this.Deserialize(din, b3);
|
||||
}
|
||||
bool flag3 = b2 > 0;
|
||||
object obj2;
|
||||
if (flag3)
|
||||
{
|
||||
obj2 = this.Deserialize(din, b2);
|
||||
}
|
||||
else
|
||||
{
|
||||
byte b4 = (byte)din.ReadByte();
|
||||
obj2 = this.Deserialize(din, b4);
|
||||
}
|
||||
dictionary.Add(obj, obj2);
|
||||
}
|
||||
arrayResult.SetValue(dictionary, (int)num);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Token: 0x0600020C RID: 524 RVA: 0x00011760 File Offset: 0x0000F960
|
||||
private Type DeserializeDictionaryType(StreamBuffer reader, out byte keyTypeCode, out byte valTypeCode)
|
||||
{
|
||||
keyTypeCode = (byte)reader.ReadByte();
|
||||
valTypeCode = (byte)reader.ReadByte();
|
||||
Protocol16.GpType gpType = (Protocol16.GpType)keyTypeCode;
|
||||
Protocol16.GpType gpType2 = (Protocol16.GpType)valTypeCode;
|
||||
bool flag = gpType == Protocol16.GpType.Unknown;
|
||||
Type type;
|
||||
if (flag)
|
||||
{
|
||||
type = typeof(object);
|
||||
}
|
||||
else
|
||||
{
|
||||
type = this.GetTypeOfCode(keyTypeCode);
|
||||
}
|
||||
bool flag2 = gpType2 == Protocol16.GpType.Unknown;
|
||||
Type type2;
|
||||
if (flag2)
|
||||
{
|
||||
type2 = typeof(object);
|
||||
}
|
||||
else
|
||||
{
|
||||
type2 = this.GetTypeOfCode(valTypeCode);
|
||||
}
|
||||
return typeof(Dictionary<, >).MakeGenericType(new Type[] { type, type2 });
|
||||
}
|
||||
|
||||
// Token: 0x04000120 RID: 288
|
||||
private readonly byte[] versionBytes = new byte[] { 1, 6 };
|
||||
|
||||
// Token: 0x04000121 RID: 289
|
||||
private readonly byte[] memShort = new byte[2];
|
||||
|
||||
// Token: 0x04000122 RID: 290
|
||||
private readonly long[] memLongBlock = new long[1];
|
||||
|
||||
// Token: 0x04000123 RID: 291
|
||||
private readonly byte[] memLongBlockBytes = new byte[8];
|
||||
|
||||
// Token: 0x04000124 RID: 292
|
||||
private static readonly float[] memFloatBlock = new float[1];
|
||||
|
||||
// Token: 0x04000125 RID: 293
|
||||
private static readonly byte[] memFloatBlockBytes = new byte[4];
|
||||
|
||||
// Token: 0x04000126 RID: 294
|
||||
private readonly double[] memDoubleBlock = new double[1];
|
||||
|
||||
// Token: 0x04000127 RID: 295
|
||||
private readonly byte[] memDoubleBlockBytes = new byte[8];
|
||||
|
||||
// Token: 0x04000128 RID: 296
|
||||
private readonly byte[] memInteger = new byte[4];
|
||||
|
||||
// Token: 0x04000129 RID: 297
|
||||
private readonly byte[] memLong = new byte[8];
|
||||
|
||||
// Token: 0x0400012A RID: 298
|
||||
private readonly byte[] memFloat = new byte[4];
|
||||
|
||||
// Token: 0x0400012B RID: 299
|
||||
private readonly byte[] memDouble = new byte[8];
|
||||
|
||||
// Token: 0x0400012C RID: 300
|
||||
private byte[] memString;
|
||||
|
||||
// Token: 0x02000049 RID: 73
|
||||
public enum GpType : byte
|
||||
{
|
||||
// Token: 0x040001B0 RID: 432
|
||||
Unknown,
|
||||
// Token: 0x040001B1 RID: 433
|
||||
Array = 121,
|
||||
// Token: 0x040001B2 RID: 434
|
||||
Boolean = 111,
|
||||
// Token: 0x040001B3 RID: 435
|
||||
Byte = 98,
|
||||
// Token: 0x040001B4 RID: 436
|
||||
ByteArray = 120,
|
||||
// Token: 0x040001B5 RID: 437
|
||||
ObjectArray = 122,
|
||||
// Token: 0x040001B6 RID: 438
|
||||
Short = 107,
|
||||
// Token: 0x040001B7 RID: 439
|
||||
Float = 102,
|
||||
// Token: 0x040001B8 RID: 440
|
||||
Dictionary = 68,
|
||||
// Token: 0x040001B9 RID: 441
|
||||
Double = 100,
|
||||
// Token: 0x040001BA RID: 442
|
||||
Hashtable = 104,
|
||||
// Token: 0x040001BB RID: 443
|
||||
Integer,
|
||||
// Token: 0x040001BC RID: 444
|
||||
IntegerArray = 110,
|
||||
// Token: 0x040001BD RID: 445
|
||||
Long = 108,
|
||||
// Token: 0x040001BE RID: 446
|
||||
String = 115,
|
||||
// Token: 0x040001BF RID: 447
|
||||
StringArray = 97,
|
||||
// Token: 0x040001C0 RID: 448
|
||||
Custom = 99,
|
||||
// Token: 0x040001C1 RID: 449
|
||||
Null = 42,
|
||||
// Token: 0x040001C2 RID: 450
|
||||
EventData = 101,
|
||||
// Token: 0x040001C3 RID: 451
|
||||
OperationRequest = 113,
|
||||
// Token: 0x040001C4 RID: 452
|
||||
OperationResponse = 112
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user