public Tuple <T> ReadValue(Reader reader, SerializerSession session, Field field)
{
if (field.WireType != WireType.TagDelimited)
{
ThrowUnsupportedWireTypeException(field);
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(session);
var item1 = default(T);
uint fieldId = 0;
while (true)
{
var header = reader.ReadFieldHeader(session);
if (header.IsEndBaseOrEndObject)
{
break;
}
fieldId += header.FieldIdDelta;
switch (fieldId)
{
case 0:
item1 = this.valueCodec.ReadValue(reader, session, header);
break;
default:
reader.ConsumeUnknownField(session, header);
break;
}
}
var result = new Tuple <T>(item1);
ReferenceCodec.RecordObject(session, result, placeholderReferenceId);
return(result);
}
public static double ReadValue <TInput>(ref Reader <TInput> reader, Field field)
{
ReferenceCodec.MarkValueField(reader.Session);
switch (field.WireType)
{
case WireType.Fixed32:
return(reader.ReadFloat());
case WireType.Fixed64:
return(reader.ReadDouble());
case WireType.LengthPrefixed:
var length = reader.ReadVarUInt32();
if (length != DecimalWidth)
{
throw new UnexpectedLengthPrefixValueException("double", DecimalWidth, length, field.ToString());
}
return((double)reader.ReadDecimal());
default:
ThrowWireTypeOutOfRange(field.WireType);
return(0);
}
}
public void WriteField(Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, ValueTuple value)
{
ReferenceCodec.MarkValueField(session);
writer.WriteFieldHeader(session, fieldIdDelta, expectedType, value.GetType(), WireType.VarInt);
writer.WriteVarInt(0);
}
void IFieldCodec <decimal> .WriteField(Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, decimal value)
{
ReferenceCodec.MarkValueField(session);
writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(decimal), WireType.Fixed128);
writer.Write(value);
}
void IFieldCodec <ValueTuple> .WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, ValueTuple value)
{
ReferenceCodec.MarkValueField(writer.Session);
writer.WriteFieldHeader(fieldIdDelta, expectedType, value.GetType(), WireType.VarInt);
writer.WriteVarInt(0);
}
public void WriteField(Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, Guid value)
{
ReferenceCodec.MarkValueField(session);
writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(Guid), WireType.Fixed128);
writer.Write(value);
}
ushort IFieldCodec <ushort> .ReadValue(Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
return(reader.ReadUInt16(field.WireType));
}
char IFieldCodec <char> .ReadValue(Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
return((char)reader.ReadUInt8(field.WireType));
}
public static ulong ReadValue <TInput>(ref Reader <TInput> reader, Field field)
{
ReferenceCodec.MarkValueField(reader.Session);
return(reader.ReadUInt64(field.WireType));
}
public static void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, TimeSpan value) where TBufferWriter : IBufferWriter <byte>
{
ReferenceCodec.MarkValueField(writer.Session);
writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(TimeSpan), WireType.Fixed64);
writer.Write(value.Ticks);
}
public static char ReadValue(ref Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
return((char)reader.ReadUInt8(field.WireType));
}
public static void WriteField(ref Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, byte value)
{
ReferenceCodec.MarkValueField(session);
writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(byte), WireType.VarInt);
writer.WriteVarInt(value);
}
public static long ReadValue(ref Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
return(reader.ReadInt64(field.WireType));
}
public void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, object value) where TBufferWriter : IBufferWriter <byte>
{
ReferenceCodec.MarkValueField(writer.Session);
throw new NotImplementedException();
}
public object ReadValue(ref Reader reader, Field field)
{
ReferenceCodec.MarkValueField(reader.Session);
reader.SkipField(field);
return(null);
}
public void WriteField(Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, object value)
{
ReferenceCodec.MarkValueField(session);
throw new NotImplementedException();
}
public static void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, byte value) where TBufferWriter : IBufferWriter <byte>
{
ReferenceCodec.MarkValueField(writer.Session);
writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(byte), WireType.VarInt);
writer.WriteVarInt(value);
}
public object ReadValue(Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
reader.SkipField(session, field);
return(null);
}
public object ReadValue(ref Reader reader, SerializerSession session, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <T[]>(ref reader, session, field));
}
if (field.WireType != WireType.TagDelimited)
{
ThrowUnsupportedWireTypeException(field);
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(session);
Array result = null;
uint fieldId = 0;
int[] lengths = null;
int[] indices = null;
var rank = 0;
while (true)
{
var header = reader.ReadFieldHeader(session);
if (header.IsEndBaseOrEndObject)
{
break;
}
fieldId += header.FieldIdDelta;
switch (fieldId)
{
case 0:
{
lengths = this.intArrayCodec.ReadValue(ref reader, session, header);
rank = lengths.Length;
// Multi-dimensional arrays must be indexed using indexing arrays, so create one now.
indices = new int[rank];
result = Array.CreateInstance(typeof(T), lengths);
ReferenceCodec.RecordObject(session, result, placeholderReferenceId);
break;
}
case 1:
{
if (result == null)
{
return(ThrowLengthsFieldMissing());
}
var element = this.elementCodec.ReadValue(ref reader, session, header);
result.SetValue(element, indices);
// Increment the indices array by 1.
var idx = rank - 1;
while (idx >= 0 && ++indices[idx] >= lengths[idx])
{
indices[idx] = 0;
--idx;
}
break;
}
default:
reader.ConsumeUnknownField(session, header);
break;
}
}
return(result);
}
public static char ReadValue(ref Reader reader, Field field)
{
ReferenceCodec.MarkValueField(reader.Session);
return((char)reader.ReadUInt16(field.WireType));
}
sbyte IFieldCodec <sbyte> .ReadValue(Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
return(reader.ReadInt8(field.WireType));
}
public static byte ReadValue(ref Reader reader, Field field)
{
ReferenceCodec.MarkValueField(reader.Session);
return(reader.ReadUInt8(field.WireType));
}
public static void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, BitVector32 value) where TBufferWriter : IBufferWriter <byte>
{
ReferenceCodec.MarkValueField(writer.Session);
writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(BitVector32), WireType.Fixed32);
writer.Write(value.Data); // BitVector32.Data gets the value of the BitVector32 as an Int32
}
public static Type ReadValue(ref Reader reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <Type>(ref reader, field));
}
uint fieldId = 0;
var schemaType = default(SchemaType);
uint id = 0;
Type result = null;
while (true)
{
var header = reader.ReadFieldHeader();
if (header.IsEndBaseOrEndObject)
{
break;
}
ReferenceCodec.MarkValueField(reader.Session);
fieldId += header.FieldIdDelta;
switch (fieldId)
{
case 0:
schemaType = (SchemaType)reader.ReadVarUInt32();
break;
case 1:
result = reader.Session.TypeCodec.Read(ref reader);
break;
case 2:
id = reader.ReadVarUInt32();
break;
}
}
switch (schemaType)
{
case SchemaType.Referenced:
if (reader.Session.ReferencedTypes.TryGetReferencedType(id, out result))
{
return(result);
}
return(ThrowUnknownReferencedType(id));
case SchemaType.WellKnown:
if (reader.Session.WellKnownTypes.TryGetWellKnownType(id, out result))
{
return(result);
}
return(ThrowUnknownWellKnownType(id));
case SchemaType.Encoded:
if (result != null)
{
return(result);
}
return(ThrowMissingType());
default:
return(ThrowInvalidSchemaType(schemaType));
}
}
bool IFieldCodec <bool> .ReadValue(Reader reader, SerializerSession session, Field field)
{
ReferenceCodec.MarkValueField(session);
return(reader.ReadUInt8(field.WireType) == 1);
}
