/// <summary>
/// Writes a field-header, indicating the format of the next data we plan to write.
/// </summary>
public static void WriteFieldHeader(int fieldNumber, WireType wireType, ProtoWriter writer, ref State state)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (writer.WireType != WireType.None)
{
throw new InvalidOperationException("Cannot write a " + wireType.ToString()
+ " header until the " + writer.WireType.ToString() + " data has been written");
}
if (fieldNumber < 0)
{
throw new ArgumentOutOfRangeException(nameof(fieldNumber));
}
#if DEBUG
switch (wireType)
{ // validate requested header-type
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.String:
case WireType.StartGroup:
case WireType.SignedVariant:
case WireType.Variant:
break; // fine
case WireType.None:
case WireType.EndGroup:
default:
throw new ArgumentException("Invalid wire-type: " + wireType.ToString(), nameof(wireType));
}
#endif
writer._needFlush = true;
if (writer.packedFieldNumber == 0)
{
writer.fieldNumber = fieldNumber;
writer.WireType = wireType;
WriteHeaderCore(fieldNumber, wireType, writer, ref state);
}
else if (writer.packedFieldNumber == fieldNumber)
{ // we'll set things up, but note we *don't* actually write the header here
switch (wireType)
{
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.Variant:
case WireType.SignedVariant:
break; // fine
default:
throw new InvalidOperationException("Wire-type cannot be encoded as packed: " + wireType.ToString());
}
writer.fieldNumber = fieldNumber;
writer.WireType = wireType;
}
else
{
throw new InvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber.ToString() + " but received " + fieldNumber.ToString());
}
}
public static void WriteFieldHeader(int fieldNumber, WireType wireType, ProtoWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw new InvalidOperationException("Cannot write a " + wireType.ToString() + " header until the " + writer.wireType.ToString() + " data has been written");
}
if (fieldNumber < 0)
{
throw new ArgumentOutOfRangeException("fieldNumber");
}
if (writer.packedFieldNumber == 0)
{
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
WriteHeaderCore(fieldNumber, wireType, writer);
return;
}
if (writer.packedFieldNumber == fieldNumber)
{
if ((uint)wireType > 1u && wireType != WireType.Fixed32 && wireType != WireType.SignedVariant)
{
throw new InvalidOperationException("Wire-type cannot be encoded as packed: " + wireType.ToString());
}
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
return;
}
throw new InvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber.ToString() + " but received " + fieldNumber.ToString());
}
/// <summary>
/// Used for packed encoding; writes the length prefix using fixed sizes rather than using
/// buffering. Only valid for fixed-32 and fixed-64 encoding.
/// </summary>
public static void WritePackedPrefix(int elementCount, WireType wireType, ProtoWriter writer)
{
if (writer.WireType != WireType.String)
{
throw new InvalidOperationException("Invalid wire-type: " + writer.WireType);
}
if (elementCount < 0)
{
throw new ArgumentOutOfRangeException(elementCount.ToString()); //throw new ArgumentOutOfRangeException(nameof(elementCount));
}
ulong bytes;
switch (wireType)
{
// use long in case very large arrays are enabled
case WireType.Fixed32: bytes = ((ulong)elementCount) << 2; break; // x4
case WireType.Fixed64: bytes = ((ulong)elementCount) << 3; break; // x8
default:
throw new ArgumentOutOfRangeException(wireType.ToString(), "Invalid wire-type: " + wireType); //throw new ArgumentOutOfRangeException(nameof(wireType), "Invalid wire-type: " + wireType);
}
WriteUInt64Variant(bytes, writer);
writer.wireType = WireType.None;
}
public static void WriteFieldHeader(int fieldNumber, WireType wireType, ProtoWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw new InvalidOperationException(string.Concat(new string[]
{
"Cannot write a ",
wireType.ToString(),
" header until the ",
writer.wireType.ToString(),
" data has been written"
}));
}
if (fieldNumber < 0)
{
throw new ArgumentOutOfRangeException("fieldNumber");
}
if (writer.packedFieldNumber == 0)
{
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
ProtoWriter.WriteHeaderCore(fieldNumber, wireType, writer);
}
else
{
if (writer.packedFieldNumber != fieldNumber)
{
throw new InvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber.ToString() + " but received " + fieldNumber.ToString());
}
switch (wireType)
{
case WireType.Variant:
case WireType.Fixed64:
case WireType.Fixed32:
goto IL_D7;
case WireType.String:
case WireType.StartGroup:
case WireType.EndGroup:
IL_CB:
if (wireType != WireType.SignedVariant)
{
throw new InvalidOperationException("Wire-type cannot be encoded as packed: " + wireType.ToString());
}
goto IL_D7;
}
goto IL_CB;
IL_D7:
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
}
}
public void WriteFieldHeader(WireType _wireType)
{
if (mWireType != WireType.None)
{
throw new InvalidOperationException("Cannot write a " + _wireType.ToString() + " header until the " + mWireType.ToString() + " data has been written");
}
mWireType = _wireType;
WriteHeaderCore(mFieldNumber, _wireType);
}
internal static void SkipData(SerializationContext context, int fieldTag, WireType wireType)
{
switch (wireType)
{
case WireType.Variant:
context.ReadRawVariant();
break;
case WireType.Fixed32:
context.ReadBlock(4);
break;
case WireType.Fixed64:
context.ReadBlock(8);
break;
case WireType.String:
int len = context.DecodeInt32();
context.WriteTo(Stream.Null, len);
break;
case WireType.EndGroup:
throw new ProtoException("End-group not expected at this location");
case WireType.StartGroup:
context.StartGroup(fieldTag); // will be ended internally
Serializer <UnknownType> .Build();
UnknownType ut = UnknownType.Default;
Serializer <UnknownType> .Deserialize <UnknownType>(ref ut, context);
break;
default:
throw new ProtoException("Unknown wire-type " + wireType.ToString());
}
}
public static Wire ToInstance(this WireType wire)
{
return((Wire)Activator.CreateInstance(
Type.GetType(string.Concat("Core.Wires.", wire.ToString())), false));
}
/// <summary>
/// Writes a field-header, indicating the format of the next data we plan to write.
/// </summary>
public static void WriteFieldHeader(int fieldNumber, WireType wireType, ProtoWriter writer) {
if (writer == null) throw new ArgumentNullException("writer");
if (writer.wireType != WireType.None) throw new InvalidOperationException("Cannot write a " + wireType.ToString()
+ " header until the " + writer.wireType.ToString() + " data has been written");
if(fieldNumber < 0) throw new ArgumentOutOfRangeException("fieldNumber");
#if DEBUG
switch (wireType)
{ // validate requested header-type
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.String:
case WireType.StartGroup:
case WireType.SignedVariant:
case WireType.Variant:
break; // fine
case WireType.None:
case WireType.EndGroup:
default:
throw new ArgumentException("Invalid wire-type: " + wireType.ToString(), "wireType");
}
#endif
if (writer.packedFieldNumber == 0) {
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
WriteHeaderCore(fieldNumber, wireType, writer);
}
else if (writer.packedFieldNumber == fieldNumber)
{ // we'll set things up, but note we *don't* actually write the header here
switch (wireType)
{
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.Variant:
case WireType.SignedVariant:
break; // fine
default:
throw new InvalidOperationException("Wire-type cannot be encoded as packed: " + wireType.ToString());
}
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
}
else
{
throw new InvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber.ToString() + " but received " + fieldNumber.ToString());
}
}
static void WritePackedField(ProtoWriter writer, int fieldNumber, WireType wireType)
{
if (writer.packedFieldNumber == fieldNumber)
{ // we'll set things up, but note we *don't* actually write the header here
switch (wireType)
{
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.Varint:
case WireType.SignedVarint:
break; // fine
default:
ThrowHelper.ThrowInvalidOperationException("Wire-type cannot be encoded as packed: " + wireType.ToString());
break;
}
writer.fieldNumber = fieldNumber;
writer.WireType = wireType;
}
else
{
ThrowHelper.ThrowInvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber.ToString() + " but received " + fieldNumber.ToString());
}
}
public static void WriteFieldHeader(int fieldNumber, WireType wireType, ProtoWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw new InvalidOperationException(string.Concat(new string[]
{
"Cannot write a ",
wireType.ToString(),
" header until the ",
writer.wireType.ToString(),
" data has been written"
}));
}
if (fieldNumber < 0)
{
throw new ArgumentOutOfRangeException("fieldNumber");
}
if (writer.packedFieldNumber == 0)
{
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
ProtoWriter.WriteHeaderCore(fieldNumber, wireType, writer);
}
else
{
if (writer.packedFieldNumber != fieldNumber)
{
throw new InvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber.ToString() + " but received " + fieldNumber.ToString());
}
switch (wireType)
{
case WireType.Variant:
case WireType.Fixed64:
case WireType.Fixed32:
goto IL_D7;
case WireType.String:
case WireType.StartGroup:
case WireType.EndGroup:
IL_CB:
if (wireType != WireType.SignedVariant)
{
throw new InvalidOperationException("Wire-type cannot be encoded as packed: " + wireType.ToString());
}
goto IL_D7;
}
goto IL_CB;
IL_D7:
writer.fieldNumber = fieldNumber;
writer.wireType = wireType;
}
}
public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest)
{
if (dest == null)
{
throw new ArgumentNullException("dest");
}
WireType wireType = dest.WireType;
if (wireType != WireType.Fixed64)
{
if ((uint)(wireType - 2) <= 1u)
{
long num = timeSpan.Ticks;
TimeSpanScale timeSpanScale;
if (timeSpan == TimeSpan.MaxValue)
{
num = 1L;
timeSpanScale = TimeSpanScale.MinMax;
}
else if (timeSpan == TimeSpan.MinValue)
{
num = -1L;
timeSpanScale = TimeSpanScale.MinMax;
}
else if (num % 864000000000L == 0L)
{
timeSpanScale = TimeSpanScale.Days;
num /= 864000000000L;
}
else if (num % 36000000000L == 0L)
{
timeSpanScale = TimeSpanScale.Hours;
num /= 36000000000L;
}
else if (num % 600000000 == 0L)
{
timeSpanScale = TimeSpanScale.Minutes;
num /= 600000000;
}
else if (num % 10000000 == 0L)
{
timeSpanScale = TimeSpanScale.Seconds;
num /= 10000000;
}
else if (num % 10000 == 0L)
{
timeSpanScale = TimeSpanScale.Milliseconds;
num /= 10000;
}
else
{
timeSpanScale = TimeSpanScale.Ticks;
}
SubItemToken token = ProtoWriter.StartSubItem(null, dest);
if (num != 0L)
{
ProtoWriter.WriteFieldHeader(1, WireType.SignedVariant, dest);
ProtoWriter.WriteInt64(num, dest);
}
if (timeSpanScale != 0)
{
ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest);
ProtoWriter.WriteInt32((int)timeSpanScale, dest);
}
ProtoWriter.EndSubItem(token, dest);
return;
}
wireType = dest.WireType;
throw new ProtoException("Unexpected wire-type: " + wireType.ToString());
}
ProtoWriter.WriteInt64(timeSpan.Ticks, dest);
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
WireType wireType = source.WireType;
if (wireType != WireType.Fixed64)
{
if ((uint)(wireType - 2) <= 1u)
{
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale timeSpanScale = TimeSpanScale.Days;
long num = 0L;
int num2;
while ((num2 = source.ReadFieldHeader()) > 0)
{
switch (num2)
{
case 2:
timeSpanScale = (TimeSpanScale)source.ReadInt32();
break;
case 1:
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
switch (timeSpanScale)
{
case TimeSpanScale.Days:
return(num * 864000000000L);
case TimeSpanScale.Hours:
return(num * 36000000000L);
case TimeSpanScale.Minutes:
return(num * 600000000);
case TimeSpanScale.Seconds:
return(num * 10000000);
case TimeSpanScale.Milliseconds:
return(num * 10000);
case TimeSpanScale.Ticks:
return(num);
case TimeSpanScale.MinMax:
switch (num)
{
case 1L:
return(9223372036854775807L);
case -1L:
return(-9223372036854775808L);
default:
throw new ProtoException("Unknown min/max value: " + num.ToString());
}
default:
throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString());
}
}
wireType = source.WireType;
throw new ProtoException("Unexpected wire-type: " + wireType.ToString());
}
return(source.ReadInt64());
}
///////////////////////////////////////////////////////////////////////////
/// <summary>
/// 生成异常
/// </summary>
Exception createException(WireType wireType)
{
return(new ProtoException("Invalid serialization operation with wire-type " + wireType.ToString() + " at position " + _position.ToString()));
}