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); }