diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs | 659 |
1 files changed, 659 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs new file mode 100644 index 00000000..50452c07 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/BclHelpers.cs @@ -0,0 +1,659 @@ +using System;
+
+namespace ProtoBuf
+{
+ public static class BclHelpers
+ {
+ private const int FieldTimeSpanValue = 1;
+
+ private const int FieldTimeSpanScale = 2;
+
+ internal static readonly DateTime EpochOrigin = new DateTime(1970, 1, 1, 0, 0, 0, 0);
+
+ private const int FieldDecimalLow = 1;
+
+ private const int FieldDecimalHigh = 2;
+
+ private const int FieldDecimalSignScale = 3;
+
+ private const int FieldGuidLow = 1;
+
+ private const int FieldGuidHigh = 2;
+
+ private const int FieldExistingObjectKey = 1;
+
+ private const int FieldNewObjectKey = 2;
+
+ private const int FieldExistingTypeKey = 3;
+
+ private const int FieldNewTypeKey = 4;
+
+ private const int FieldTypeName = 8;
+
+ private const int FieldObject = 10;
+
+ [Flags]
+ public enum NetObjectOptions : byte
+ {
+ None = 0,
+ AsReference = 1,
+ DynamicType = 2,
+ UseConstructor = 4,
+ LateSet = 8
+ }
+
+ public static object GetUninitializedObject(Type type)
+ {
+ throw new NotSupportedException("Constructor-skipping is not supported on this platform");
+ }
+
+ public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest)
+ {
+ bool flag = dest == null;
+ if (flag)
+ {
+ throw new ArgumentNullException("dest");
+ }
+ WireType wireType = dest.WireType;
+ if (wireType != WireType.Fixed64)
+ {
+ if (wireType - WireType.String > 1)
+ {
+ throw new ProtoException("Unexpected wire-type: " + dest.WireType.ToString());
+ }
+ long num = timeSpan.Ticks;
+ bool flag2 = timeSpan == TimeSpan.MaxValue;
+ TimeSpanScale timeSpanScale;
+ if (flag2)
+ {
+ num = 1L;
+ timeSpanScale = TimeSpanScale.MinMax;
+ }
+ else
+ {
+ bool flag3 = timeSpan == TimeSpan.MinValue;
+ if (flag3)
+ {
+ num = -1L;
+ timeSpanScale = TimeSpanScale.MinMax;
+ }
+ else
+ {
+ bool flag4 = num % 864000000000L == 0L;
+ if (flag4)
+ {
+ timeSpanScale = TimeSpanScale.Days;
+ num /= 864000000000L;
+ }
+ else
+ {
+ bool flag5 = num % 36000000000L == 0L;
+ if (flag5)
+ {
+ timeSpanScale = TimeSpanScale.Hours;
+ num /= 36000000000L;
+ }
+ else
+ {
+ bool flag6 = num % 600000000L == 0L;
+ if (flag6)
+ {
+ timeSpanScale = TimeSpanScale.Minutes;
+ num /= 600000000L;
+ }
+ else
+ {
+ bool flag7 = num % 10000000L == 0L;
+ if (flag7)
+ {
+ timeSpanScale = TimeSpanScale.Seconds;
+ num /= 10000000L;
+ }
+ else
+ {
+ bool flag8 = num % 10000L == 0L;
+ if (flag8)
+ {
+ timeSpanScale = TimeSpanScale.Milliseconds;
+ num /= 10000L;
+ }
+ else
+ {
+ timeSpanScale = TimeSpanScale.Ticks;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ SubItemToken token = ProtoWriter.StartSubItem(null, dest);
+ bool flag9 = num != 0L;
+ if (flag9)
+ {
+ ProtoWriter.WriteFieldHeader(1, WireType.SignedVariant, dest);
+ ProtoWriter.WriteInt64(num, dest);
+ }
+ bool flag10 = timeSpanScale > TimeSpanScale.Days;
+ if (flag10)
+ {
+ ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest);
+ ProtoWriter.WriteInt32((int)timeSpanScale, dest);
+ }
+ ProtoWriter.EndSubItem(token, dest);
+ }
+ else
+ {
+ ProtoWriter.WriteInt64(timeSpan.Ticks, dest);
+ }
+ }
+
+ public static TimeSpan ReadTimeSpan(ProtoReader source)
+ {
+ long num = BclHelpers.ReadTimeSpanTicks(source);
+ bool flag = num == long.MinValue;
+ TimeSpan result;
+ if (flag)
+ {
+ result = TimeSpan.MinValue;
+ }
+ else
+ {
+ bool flag2 = num == long.MaxValue;
+ if (flag2)
+ {
+ result = TimeSpan.MaxValue;
+ }
+ else
+ {
+ result = TimeSpan.FromTicks(num);
+ }
+ }
+ return result;
+ }
+
+ public static DateTime ReadDateTime(ProtoReader source)
+ {
+ long num = BclHelpers.ReadTimeSpanTicks(source);
+ bool flag = num == long.MinValue;
+ DateTime result;
+ if (flag)
+ {
+ result = DateTime.MinValue;
+ }
+ else
+ {
+ bool flag2 = num == long.MaxValue;
+ if (flag2)
+ {
+ result = DateTime.MaxValue;
+ }
+ else
+ {
+ result = BclHelpers.EpochOrigin.AddTicks(num);
+ }
+ }
+ return result;
+ }
+
+ public static void WriteDateTime(DateTime value, ProtoWriter dest)
+ {
+ bool flag = dest == null;
+ if (flag)
+ {
+ throw new ArgumentNullException("dest");
+ }
+ WireType wireType = dest.WireType;
+ TimeSpan timeSpan;
+ if (wireType - WireType.String > 1)
+ {
+ timeSpan = value - BclHelpers.EpochOrigin;
+ }
+ else
+ {
+ bool flag2 = value == DateTime.MaxValue;
+ if (flag2)
+ {
+ timeSpan = TimeSpan.MaxValue;
+ }
+ else
+ {
+ bool flag3 = value == DateTime.MinValue;
+ if (flag3)
+ {
+ timeSpan = TimeSpan.MinValue;
+ }
+ else
+ {
+ timeSpan = value - BclHelpers.EpochOrigin;
+ }
+ }
+ }
+ BclHelpers.WriteTimeSpan(timeSpan, dest);
+ }
+
+ private static long ReadTimeSpanTicks(ProtoReader source)
+ {
+ WireType wireType = source.WireType;
+ long result;
+ if (wireType != WireType.Fixed64)
+ {
+ if (wireType - WireType.String > 1)
+ {
+ throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
+ }
+ SubItemToken token = ProtoReader.StartSubItem(source);
+ TimeSpanScale timeSpanScale = TimeSpanScale.Days;
+ long num = 0L;
+ int num2;
+ while ((num2 = source.ReadFieldHeader()) > 0)
+ {
+ int num3 = num2;
+ if (num3 != 1)
+ {
+ if (num3 != 2)
+ {
+ source.SkipField();
+ }
+ else
+ {
+ timeSpanScale = (TimeSpanScale)source.ReadInt32();
+ }
+ }
+ else
+ {
+ source.Assert(WireType.SignedVariant);
+ num = source.ReadInt64();
+ }
+ }
+ ProtoReader.EndSubItem(token, source);
+ TimeSpanScale timeSpanScale2 = timeSpanScale;
+ switch (timeSpanScale2)
+ {
+ case TimeSpanScale.Days:
+ result = num * 864000000000L;
+ break;
+ case TimeSpanScale.Hours:
+ result = num * 36000000000L;
+ break;
+ case TimeSpanScale.Minutes:
+ result = num * 600000000L;
+ break;
+ case TimeSpanScale.Seconds:
+ result = num * 10000000L;
+ break;
+ case TimeSpanScale.Milliseconds:
+ result = num * 10000L;
+ break;
+ case TimeSpanScale.Ticks:
+ result = num;
+ break;
+ default:
+ {
+ if (timeSpanScale2 != TimeSpanScale.MinMax)
+ {
+ throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString());
+ }
+ long num4 = num;
+ if (num4 != -1L)
+ {
+ if (num4 != 1L)
+ {
+ throw new ProtoException("Unknown min/max value: " + num.ToString());
+ }
+ result = long.MaxValue;
+ }
+ else
+ {
+ result = long.MinValue;
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ result = source.ReadInt64();
+ }
+ return result;
+ }
+
+ public static decimal ReadDecimal(ProtoReader reader)
+ {
+ ulong num = 0UL;
+ uint num2 = 0u;
+ uint num3 = 0u;
+ SubItemToken token = ProtoReader.StartSubItem(reader);
+ int num4;
+ while ((num4 = reader.ReadFieldHeader()) > 0)
+ {
+ switch (num4)
+ {
+ case 1:
+ num = reader.ReadUInt64();
+ break;
+ case 2:
+ num2 = reader.ReadUInt32();
+ break;
+ case 3:
+ num3 = reader.ReadUInt32();
+ break;
+ default:
+ reader.SkipField();
+ break;
+ }
+ }
+ ProtoReader.EndSubItem(token, reader);
+ bool flag = num == 0UL && num2 == 0u;
+ decimal result;
+ if (flag)
+ {
+ result = 0m;
+ }
+ else
+ {
+ int lo = (int)(num & /*(ulong)-1 */ulong.MaxValue);
+ int mid = (int)(num >> 32 & /*(ulong)-1*/ulong.MaxValue);
+ int hi = (int)num2;
+ bool isNegative = (num3 & 1u) == 1u;
+ byte scale = (byte)((num3 & 510u) >> 1);
+ result = new decimal(lo, mid, hi, isNegative, scale);
+ }
+ return result;
+ }
+
+ public static void WriteDecimal(decimal value, ProtoWriter writer)
+ {
+ int[] bits = decimal.GetBits(value);
+ ulong num = (ulong)((ulong)((long)bits[1]) << 32);
+ ulong num2 = (ulong)((long)bits[0] & (long)(long.MaxValue));
+ ulong num3 = num | num2;
+ uint num4 = (uint)bits[2];
+ uint num5 = (uint)((bits[3] >> 15 & 510) | (bits[3] >> 31 & 1));
+ SubItemToken token = ProtoWriter.StartSubItem(null, writer);
+ bool flag = num3 > 0UL;
+ if (flag)
+ {
+ ProtoWriter.WriteFieldHeader(1, WireType.Variant, writer);
+ ProtoWriter.WriteUInt64(num3, writer);
+ }
+ bool flag2 = num4 > 0u;
+ if (flag2)
+ {
+ ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer);
+ ProtoWriter.WriteUInt32(num4, writer);
+ }
+ bool flag3 = num5 > 0u;
+ if (flag3)
+ {
+ ProtoWriter.WriteFieldHeader(3, WireType.Variant, writer);
+ ProtoWriter.WriteUInt32(num5, writer);
+ }
+ ProtoWriter.EndSubItem(token, writer);
+ }
+
+ public static void WriteGuid(Guid value, ProtoWriter dest)
+ {
+ byte[] data = value.ToByteArray();
+ SubItemToken token = ProtoWriter.StartSubItem(null, dest);
+ bool flag = value != Guid.Empty;
+ if (flag)
+ {
+ ProtoWriter.WriteFieldHeader(1, WireType.Fixed64, dest);
+ ProtoWriter.WriteBytes(data, 0, 8, dest);
+ ProtoWriter.WriteFieldHeader(2, WireType.Fixed64, dest);
+ ProtoWriter.WriteBytes(data, 8, 8, dest);
+ }
+ ProtoWriter.EndSubItem(token, dest);
+ }
+
+ public static Guid ReadGuid(ProtoReader source)
+ {
+ ulong num = 0UL;
+ ulong num2 = 0UL;
+ SubItemToken token = ProtoReader.StartSubItem(source);
+ int num3;
+ while ((num3 = source.ReadFieldHeader()) > 0)
+ {
+ int num4 = num3;
+ if (num4 != 1)
+ {
+ if (num4 != 2)
+ {
+ source.SkipField();
+ }
+ else
+ {
+ num2 = source.ReadUInt64();
+ }
+ }
+ else
+ {
+ num = source.ReadUInt64();
+ }
+ }
+ ProtoReader.EndSubItem(token, source);
+ bool flag = num == 0UL && num2 == 0UL;
+ Guid result;
+ if (flag)
+ {
+ result = Guid.Empty;
+ }
+ else
+ {
+ uint num5 = (uint)(num >> 32);
+ uint a = (uint)num;
+ uint num6 = (uint)(num2 >> 32);
+ uint num7 = (uint)num2;
+ result = new Guid((int)a, (short)num5, (short)(num5 >> 16), (byte)num7, (byte)(num7 >> 8), (byte)(num7 >> 16), (byte)(num7 >> 24), (byte)num6, (byte)(num6 >> 8), (byte)(num6 >> 16), (byte)(num6 >> 24));
+ }
+ return result;
+ }
+
+ public static object ReadNetObject(object value, ProtoReader source, int key, Type type, BclHelpers.NetObjectOptions options)
+ {
+ SubItemToken token = ProtoReader.StartSubItem(source);
+ int num = -1;
+ int num2 = -1;
+ int num3;
+ while ((num3 = source.ReadFieldHeader()) > 0)
+ {
+ switch (num3)
+ {
+ case 1:
+ {
+ int key2 = source.ReadInt32();
+ value = source.NetCache.GetKeyedObject(key2);
+ break;
+ }
+ case 2:
+ num = source.ReadInt32();
+ break;
+ case 3:
+ {
+ int key2 = source.ReadInt32();
+ type = (Type)source.NetCache.GetKeyedObject(key2);
+ key = source.GetTypeKey(ref type);
+ break;
+ }
+ case 4:
+ num2 = source.ReadInt32();
+ break;
+ case 5:
+ case 6:
+ case 7:
+ case 9:
+ goto IL_27E;
+ case 8:
+ {
+ string text = source.ReadString();
+ type = source.DeserializeType(text);
+ bool flag = type == null;
+ if (flag)
+ {
+ throw new ProtoException("Unable to resolve type: " + text + " (you can use the TypeModel.DynamicTypeFormatting event to provide a custom mapping)");
+ }
+ bool flag2 = type == typeof(string);
+ if (flag2)
+ {
+ key = -1;
+ }
+ else
+ {
+ key = source.GetTypeKey(ref type);
+ bool flag3 = key < 0;
+ if (flag3)
+ {
+ throw new InvalidOperationException("Dynamic type is not a contract-type: " + type.Name);
+ }
+ }
+ break;
+ }
+ case 10:
+ {
+ bool flag4 = type == typeof(string);
+ bool flag5 = value == null;
+ bool flag6 = flag5 && (flag4 || (options & BclHelpers.NetObjectOptions.LateSet) > BclHelpers.NetObjectOptions.None);
+ bool flag7 = num >= 0 && !flag6;
+ if (flag7)
+ {
+ bool flag8 = value == null;
+ if (flag8)
+ {
+ source.TrapNextObject(num);
+ }
+ else
+ {
+ source.NetCache.SetKeyedObject(num, value);
+ }
+ bool flag9 = num2 >= 0;
+ if (flag9)
+ {
+ source.NetCache.SetKeyedObject(num2, type);
+ }
+ }
+ object obj = value;
+ bool flag10 = flag4;
+ if (flag10)
+ {
+ value = source.ReadString();
+ }
+ else
+ {
+ value = ProtoReader.ReadTypedObject(obj, key, source, type);
+ }
+ bool flag11 = num >= 0;
+ if (flag11)
+ {
+ bool flag12 = flag5 && !flag6;
+ if (flag12)
+ {
+ obj = source.NetCache.GetKeyedObject(num);
+ }
+ bool flag13 = flag6;
+ if (flag13)
+ {
+ source.NetCache.SetKeyedObject(num, value);
+ bool flag14 = num2 >= 0;
+ if (flag14)
+ {
+ source.NetCache.SetKeyedObject(num2, type);
+ }
+ }
+ }
+ bool flag15 = num >= 0 && !flag6 && obj != value;
+ if (flag15)
+ {
+ throw new ProtoException("A reference-tracked object changed reference during deserialization");
+ }
+ bool flag16 = num < 0 && num2 >= 0;
+ if (flag16)
+ {
+ source.NetCache.SetKeyedObject(num2, type);
+ }
+ break;
+ }
+ default:
+ goto IL_27E;
+ }
+ continue;
+ IL_27E:
+ source.SkipField();
+ }
+ bool flag17 = num >= 0 && (options & BclHelpers.NetObjectOptions.AsReference) == BclHelpers.NetObjectOptions.None;
+ if (flag17)
+ {
+ throw new ProtoException("Object key in input stream, but reference-tracking was not expected");
+ }
+ ProtoReader.EndSubItem(token, source);
+ return value;
+ }
+
+ public static void WriteNetObject(object value, ProtoWriter dest, int key, BclHelpers.NetObjectOptions options)
+ {
+ bool flag = dest == null;
+ if (flag)
+ {
+ throw new ArgumentNullException("dest");
+ }
+ bool flag2 = (options & BclHelpers.NetObjectOptions.DynamicType) > BclHelpers.NetObjectOptions.None;
+ bool flag3 = (options & BclHelpers.NetObjectOptions.AsReference) > BclHelpers.NetObjectOptions.None;
+ WireType wireType = dest.WireType;
+ SubItemToken token = ProtoWriter.StartSubItem(null, dest);
+ bool flag4 = true;
+ bool flag5 = flag3;
+ if (flag5)
+ {
+ bool flag6;
+ int value2 = dest.NetCache.AddObjectKey(value, out flag6);
+ ProtoWriter.WriteFieldHeader(flag6 ? 1 : 2, WireType.Variant, dest);
+ ProtoWriter.WriteInt32(value2, dest);
+ bool flag7 = flag6;
+ if (flag7)
+ {
+ flag4 = false;
+ }
+ }
+ bool flag8 = flag4;
+ if (flag8)
+ {
+ bool flag9 = flag2;
+ if (flag9)
+ {
+ Type type = value.GetType();
+ bool flag10 = !(value is string);
+ if (flag10)
+ {
+ key = dest.GetTypeKey(ref type);
+ bool flag11 = key < 0;
+ if (flag11)
+ {
+ throw new InvalidOperationException("Dynamic type is not a contract-type: " + type.Name);
+ }
+ }
+ bool flag12;
+ int value3 = dest.NetCache.AddObjectKey(type, out flag12);
+ ProtoWriter.WriteFieldHeader(flag12 ? 3 : 4, WireType.Variant, dest);
+ ProtoWriter.WriteInt32(value3, dest);
+ bool flag13 = !flag12;
+ if (flag13)
+ {
+ ProtoWriter.WriteFieldHeader(8, WireType.String, dest);
+ ProtoWriter.WriteString(dest.SerializeType(type), dest);
+ }
+ }
+ ProtoWriter.WriteFieldHeader(10, wireType, dest);
+ bool flag14 = value is string;
+ if (flag14)
+ {
+ ProtoWriter.WriteString((string)value, dest);
+ }
+ else
+ {
+ ProtoWriter.WriteObject(value, key, dest);
+ }
+ }
+ ProtoWriter.EndSubItem(token, dest);
+ }
+ }
+}
|