private static SubItemToken StartSubItem(object instance, ProtoWriter writer, bool allowFixed)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (++writer.depth > 0x19)
{
writer.CheckRecursionStackAndPush(instance);
}
if (writer.packedFieldNumber != 0)
{
throw new InvalidOperationException("Cannot begin a sub-item while performing packed encoding");
}
switch (writer.wireType)
{
case WireType.String:
writer.wireType = WireType.None;
DemandSpace(0x20, writer);
writer.flushLock++;
writer.position++;
return(new SubItemToken(writer.ioIndex++));
case WireType.StartGroup:
writer.wireType = WireType.None;
return(new SubItemToken(-writer.fieldNumber));
case WireType.Fixed32:
{
if (!allowFixed)
{
throw CreateException(writer);
}
DemandSpace(0x20, writer);
writer.flushLock++;
SubItemToken token = new SubItemToken(writer.ioIndex);
IncrementedAndReset(4, writer);
return(token);
}
}
throw CreateException(writer);
}
public static void WriteObject(object value, int key, ProtoWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.model == null)
{
throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided");
}
SubItemToken token = StartSubItem(value, writer);
if (key >= 0)
{
writer.model.Serialize(key, value, writer);
}
else if ((writer.model == null) || !writer.model.TrySerializeAuxiliaryType(writer, value.GetType(), DataFormat.Default, 1, value, false))
{
TypeModel.ThrowUnexpectedType(value.GetType());
}
EndSubItem(token, writer);
}
public static Guid ReadGuid(ProtoReader source)
{
int num3;
ulong num = 0L;
ulong num2 = 0L;
SubItemToken token = ProtoReader.StartSubItem(source);
while ((num3 = source.ReadFieldHeader()) > 0)
{
switch (num3)
{
case 1:
{
num = source.ReadUInt64();
continue;
}
case 2:
{
num2 = source.ReadUInt64();
continue;
}
}
source.SkipField();
}
ProtoReader.EndSubItem(token, source);
if ((num == 0L) && (num2 == 0L))
{
return(Guid.Empty);
}
uint num4 = (uint)(num >> 0x20);
uint num5 = (uint)num;
uint num6 = (uint)(num2 >> 0x20);
uint num7 = (uint)num2;
return(new Guid((int)num5, (short)num4, (short)(num4 >> 0x10), (byte)num7, (byte)(num7 >> 8), (byte)(num7 >> 0x10), (byte)(num7 >> 0x18), (byte)num6, (byte)(num6 >> 8), (byte)(num6 >> 0x10), (byte)(num6 >> 0x18)));
}
private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw CreateException(writer);
}
int index = token.value;
if (writer.depth <= 0)
{
throw CreateException(writer);
}
if (writer.depth-- > 0x19)
{
writer.PopRecursionStack();
}
writer.packedFieldNumber = 0;
if (index < 0)
{
WriteHeaderCore(-index, WireType.EndGroup, writer);
writer.wireType = WireType.None;
}
else
{
int num2;
switch (style)
{
case PrefixStyle.Base128:
{
num2 = (writer.ioIndex - index) - 1;
int required = 0;
uint num5 = (uint)num2;
while ((num5 = num5 >> 7) != 0)
{
required++;
}
if (required == 0)
{
writer.ioBuffer[index] = (byte)(num2 & 0x7f);
}
else
{
DemandSpace(required, writer);
byte[] ioBuffer = writer.ioBuffer;
Helpers.BlockCopy(ioBuffer, index + 1, ioBuffer, (index + 1) + required, num2);
num5 = (uint)num2;
do
{
ioBuffer[index++] = (byte)((num5 & 0x7f) | 0x80);
}while ((num5 = num5 >> 7) != 0);
ioBuffer[index - 1] = (byte)(ioBuffer[index - 1] & -129);
writer.position += required;
writer.ioIndex += required;
}
break;
}
case PrefixStyle.Fixed32:
num2 = (writer.ioIndex - index) - 4;
WriteInt32ToBuffer(num2, writer.ioBuffer, index);
break;
case PrefixStyle.Fixed32BigEndian:
{
num2 = (writer.ioIndex - index) - 4;
byte[] buffer = writer.ioBuffer;
WriteInt32ToBuffer(num2, buffer, index);
byte num3 = buffer[index];
buffer[index] = buffer[index + 3];
buffer[index + 3] = num3;
num3 = buffer[index + 1];
buffer[index + 1] = buffer[index + 2];
buffer[index + 2] = num3;
break;
}
default:
throw new ArgumentOutOfRangeException("style");
}
if ((--writer.flushLock == 0) && (writer.ioIndex >= 0x400))
{
Flush(writer);
}
}
}
public static void EndSubItem(SubItemToken token, ProtoWriter writer)
{
EndSubItem(token, writer, PrefixStyle.Base128);
}
public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest)
{
long ticks;
TimeSpanScale minMax;
if (dest == null)
{
throw new ArgumentNullException("dest");
}
switch (dest.WireType)
{
case WireType.Fixed64:
ProtoWriter.WriteInt64(timeSpan.Ticks, dest);
return;
case WireType.String:
case WireType.StartGroup:
ticks = timeSpan.Ticks;
if (!(timeSpan == TimeSpan.MaxValue))
{
if (timeSpan == TimeSpan.MinValue)
{
ticks = -1L;
minMax = TimeSpanScale.MinMax;
}
else if ((ticks % 0xc92a69c000L) == 0L)
{
minMax = TimeSpanScale.Days;
ticks /= 0xc92a69c000L;
}
else if ((ticks % 0x861c46800L) == 0L)
{
minMax = TimeSpanScale.Hours;
ticks /= 0x861c46800L;
}
else if ((ticks % 0x23c34600L) == 0L)
{
minMax = TimeSpanScale.Minutes;
ticks /= 0x23c34600L;
}
else if ((ticks % 0x989680L) == 0L)
{
minMax = TimeSpanScale.Seconds;
ticks /= 0x989680L;
}
else if ((ticks % 0x2710L) == 0L)
{
minMax = TimeSpanScale.Milliseconds;
ticks /= 0x2710L;
}
else
{
minMax = TimeSpanScale.Ticks;
}
break;
}
ticks = 1L;
minMax = TimeSpanScale.MinMax;
break;
default:
throw new ProtoException("Unexpected wire-type: " + dest.WireType.ToString());
}
SubItemToken token = ProtoWriter.StartSubItem(null, dest);
if (ticks != 0L)
{
ProtoWriter.WriteFieldHeader(1, WireType.SignedVariant, dest);
ProtoWriter.WriteInt64(ticks, dest);
}
if (minMax != TimeSpanScale.Days)
{
ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest);
ProtoWriter.WriteInt32((int)minMax, dest);
}
ProtoWriter.EndSubItem(token, dest);
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
long num2;
switch (source.WireType)
{
case WireType.Fixed64:
return(source.ReadInt64());
case WireType.String:
case WireType.StartGroup:
{
int num;
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale days = TimeSpanScale.Days;
num2 = 0L;
Label_0065:
if ((num = source.ReadFieldHeader()) <= 0)
{
ProtoReader.EndSubItem(token, source);
switch (days)
{
case TimeSpanScale.Days:
return(num2 * 0xc92a69c000L);
case TimeSpanScale.Hours:
return(num2 * 0x861c46800L);
case TimeSpanScale.Minutes:
return(num2 * 0x23c34600L);
case TimeSpanScale.Seconds:
return(num2 * 0x989680L);
case TimeSpanScale.Milliseconds:
return(num2 * 0x2710L);
case TimeSpanScale.Ticks:
return(num2);
case TimeSpanScale.MinMax:
{
long num4 = num2;
if ((num4 <= 1L) && (num4 >= -1L))
{
switch (((int)(num4 - -1L)))
{
case 0:
return(-9223372036854775808L);
case 2:
return(0x7fffffffffffffffL);
}
}
goto Label_0115;
}
}
throw new ProtoException("Unknown timescale: " + days.ToString());
}
switch (num)
{
case 1:
source.Assert(WireType.SignedVariant);
num2 = source.ReadInt64();
goto Label_0065;
case 2:
days = (TimeSpanScale)source.ReadInt32();
goto Label_0065;
}
source.SkipField();
goto Label_0065;
}
default:
throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
}
Label_0115:
throw new ProtoException("Unknown min/max value: " + num2.ToString());
}
public static object ReadNetObject(object value, ProtoReader source, int key, Type type, NetObjectOptions options)
{
int num;
SubItemToken token = ProtoReader.StartSubItem(source);
int newObjectKey = -1;
int num3 = -1;
while ((num = source.ReadFieldHeader()) > 0)
{
int num4;
bool flag;
bool flag2;
bool flag3;
object keyedObject;
switch (num)
{
case 1:
{
num4 = source.ReadInt32();
value = source.NetCache.GetKeyedObject(num4);
continue;
}
case 2:
{
newObjectKey = source.ReadInt32();
continue;
}
case 3:
{
num4 = source.ReadInt32();
type = (Type)source.NetCache.GetKeyedObject(num4);
key = source.GetTypeKey(ref type);
continue;
}
case 4:
{
num3 = source.ReadInt32();
continue;
}
case 8:
{
string str = source.ReadString();
type = source.DeserializeType(str);
if (type == null)
{
throw new ProtoException("Unable to resolve type: " + str + " (you can use the TypeModel.DynamicTypeFormatting event to provide a custom mapping)");
}
break;
}
case 10:
flag = type == typeof(string);
flag2 = value == null;
flag3 = flag2 && (flag || (((byte)(options & NetObjectOptions.LateSet)) != 0));
if ((newObjectKey < 0) || flag3)
{
goto Label_0180;
}
if (value != null)
{
goto Label_0162;
}
source.TrapNextObject(newObjectKey);
goto Label_016F;
default:
goto Label_020D;
}
if (type == typeof(string))
{
key = -1;
continue;
}
key = source.GetTypeKey(ref type);
if (key >= 0)
{
continue;
}
throw new InvalidOperationException("Dynamic type is not a contract-type: " + type.Name);
Label_0162:
source.NetCache.SetKeyedObject(newObjectKey, value);
Label_016F:
if (num3 >= 0)
{
source.NetCache.SetKeyedObject(num3, type);
}
Label_0180:
keyedObject = value;
if (flag)
{
value = source.ReadString();
}
else
{
value = ProtoReader.ReadTypedObject(keyedObject, key, source, type);
}
if (newObjectKey >= 0)
{
if (flag2 && !flag3)
{
keyedObject = source.NetCache.GetKeyedObject(newObjectKey);
}
if (flag3)
{
source.NetCache.SetKeyedObject(newObjectKey, value);
if (num3 >= 0)
{
source.NetCache.SetKeyedObject(num3, type);
}
}
}
if (((newObjectKey >= 0) && !flag3) && !object.ReferenceEquals(keyedObject, value))
{
throw new ProtoException("A reference-tracked object changed reference during deserialization");
}
if ((newObjectKey < 0) && (num3 >= 0))
{
source.NetCache.SetKeyedObject(num3, type);
}
continue;
Label_020D:
source.SkipField();
}
if ((newObjectKey >= 0) && (((byte)(options & NetObjectOptions.AsReference)) == 0))
{
throw new ProtoException("Object key in input stream, but reference-tracking was not expected");
}
ProtoReader.EndSubItem(token, source);
return(value);
}
