void IFieldCodec <KeyValuePair <TKey, TValue> > .WriteField(ref Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, KeyValuePair <TKey, TValue> value) { ReferenceCodec.MarkValueField(session); writer.WriteFieldHeader(session, fieldIdDelta, expectedType, value.GetType(), WireType.TagDelimited); this.keyCodec.WriteField(ref writer, session, 0, typeof(TKey), value.Key); this.valueCodec.WriteField(ref writer, session, 1, typeof(TValue), value.Value); writer.WriteEndObject(); }
void IFieldCodec <double> .WriteField( Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, double value) { ReferenceCodec.MarkValueField(session); writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(double), WireType.Fixed64); writer.Write(value); }
ValueTuple IFieldCodec <ValueTuple> .ReadValue <TInput>(ref Reader <TInput> reader, Field field) { if (field.WireType != WireType.VarInt) { ThrowUnsupportedWireTypeException(field); } ReferenceCodec.MarkValueField(reader.Session); _ = reader.ReadVarUInt64(); return(default);
public ValueTuple ReadValue(Reader reader, SerializerSession session, Field field) { if (field.WireType != WireType.VarInt) { ThrowUnsupportedWireTypeException(field); } ReferenceCodec.MarkValueField(session); reader.ReadVarUInt64(); return(default);
public static void WriteField(ref Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, decimal value) { ReferenceCodec.MarkValueField(session); writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(decimal), WireType.Fixed128); var ints = Decimal.GetBits(value); foreach (var part in ints) { writer.Write(part); } }
public static void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, decimal value) where TBufferWriter : IBufferWriter <byte> { ReferenceCodec.MarkValueField(writer.Session); writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(decimal), WireType.Fixed128); var ints = decimal.GetBits(value); foreach (var part in ints) { writer.Write(part); } }
void IFieldCodec <float> .WriteField( Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, float value) { ReferenceCodec.MarkValueField(session); writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(float), WireType.Fixed32); writer.Write(value); }
void IFieldCodec <sbyte> .WriteField( Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, sbyte value) { ReferenceCodec.MarkValueField(session); writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(sbyte), WireType.VarInt); writer.WriteVarInt(value); }
void IFieldCodec <KeyValuePair <TKey, TValue> > .WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, KeyValuePair <TKey, TValue> value) { ReferenceCodec.MarkValueField(writer.Session); writer.WriteFieldHeader(fieldIdDelta, expectedType, value.GetType(), WireType.TagDelimited); _keyCodec.WriteField(ref writer, 0, typeof(TKey), value.Key); _valueCodec.WriteField(ref writer, 1, typeof(TValue), value.Value); writer.WriteEndObject(); }
public static void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, uint value) where TBufferWriter : IBufferWriter <byte> { ReferenceCodec.MarkValueField(writer.Session); if (value > 1 << 20) { writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(uint), WireType.Fixed32); writer.Write(value); } else { writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(uint), WireType.VarInt); writer.WriteVarInt(value); } }
public static void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, Guid value) where TBufferWriter : IBufferWriter <byte> { ReferenceCodec.MarkValueField(writer.Session); writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(Guid), WireType.Fixed128); #if NETCOREAPP writer.EnsureContiguous(Width); if (value.TryWriteBytes(writer.WritableSpan)) { writer.AdvanceSpan(Width); return; } #endif writer.Write(value.ToByteArray()); }
public static void WriteField(ref Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, Guid value) { ReferenceCodec.MarkValueField(session); writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(Guid), WireType.Fixed128); #if NETCOREAPP2_1 writer.EnsureContiguous(Width); if (value.TryWriteBytes(writer.WritableSpan)) { writer.AdvanceSpan(Width); return; } #endif writer.Write(value.ToByteArray()); }
public static void WriteField(ref Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, uint value) { ReferenceCodec.MarkValueField(session); if (value > 1 << 20) { writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(uint), WireType.Fixed32); writer.Write(value); } else { writer.WriteFieldHeader(session, fieldIdDelta, expectedType, typeof(uint), WireType.VarInt); writer.WriteVarInt(value); } }
public static Guid ReadValue(ref Reader reader, Field field) { ReferenceCodec.MarkValueField(reader.Session); #if NETCOREAPP2_1 if (reader.TryReadBytes(Width, out var readOnly)) { return(new Guid(readOnly)); } // TODO: stackalloc Span <byte> bytes = new byte[Width]; reader.ReadBytes(in bytes); return(new Guid(bytes)); #else return(new Guid(reader.ReadBytes(Width))); #endif }
void IFieldCodec <int> .WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, int value) { ReferenceCodec.MarkValueField(writer.Session); if (value > 1 << 20 || -value > 1 << 20) { writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(int), WireType.Fixed32); writer.Write(value); } else { writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(int), WireType.VarInt); writer.WriteVarInt(value); } }
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.Fixed128: return((double)reader.ReadDecimal()); default: ThrowWireTypeOutOfRange(field.WireType); return(0); } }
double IFieldCodec <double> .ReadValue(Reader reader, SerializerSession session, Field field) { ReferenceCodec.MarkValueField(session); switch (field.WireType) { case WireType.Fixed32: return(reader.ReadFloat()); case WireType.Fixed64: return(reader.ReadDouble()); case WireType.Fixed128: return((double)reader.ReadDecimal()); default: ThrowWireTypeOutOfRange(field.WireType); return(0); } }
public static Guid ReadValue(ref Reader reader, Field field) { ReferenceCodec.MarkValueField(reader.Session); #if NETCOREAPP if (reader.TryReadBytes(Width, out var readOnly)) { return(new Guid(readOnly)); } Span <byte> bytes = stackalloc byte[Width]; for (var i = 0; i < Width; i++) { bytes[i] = reader.ReadByte(); } return(new Guid(bytes)); #else return(new Guid(reader.ReadBytes(Width))); #endif }
public static decimal ReadValue <TInput>(ref Reader <TInput> reader, Field field) { ReferenceCodec.MarkValueField(reader.Session); switch (field.WireType) { case WireType.Fixed32: { var value = reader.ReadFloat(); if (value > (float)decimal.MaxValue || value < (float)decimal.MinValue) { ThrowValueOutOfRange(value); } return((decimal)value); } case WireType.Fixed64: { var value = reader.ReadDouble(); if (value > (double)decimal.MaxValue || value < (double)decimal.MinValue) { ThrowValueOutOfRange(value); } return((decimal)value); } case WireType.LengthPrefixed: var length = reader.ReadVarUInt32(); if (length != Width) { throw new UnexpectedLengthPrefixValueException("decimal", Width, length, field.ToString()); } return(reader.ReadDecimal()); default: ThrowWireTypeOutOfRange(field.WireType); return(0); } }
public KeyValuePair <TKey, TValue> ReadValue <TInput>(ref Reader <TInput> reader, Field field) { if (field.WireType != WireType.TagDelimited) { ThrowUnsupportedWireTypeException(field); } ReferenceCodec.MarkValueField(reader.Session); var key = default(TKey); var value = default(TValue); uint fieldId = 0; while (true) { var header = reader.ReadFieldHeader(); if (header.IsEndBaseOrEndObject) { break; } fieldId += header.FieldIdDelta; switch (fieldId) { case 0: key = _keyCodec.ReadValue(ref reader, header); break; case 1: value = _valueCodec.ReadValue(ref reader, header); break; default: reader.ConsumeUnknownField(header); break; } } return(new KeyValuePair <TKey, TValue>(key, value)); }
public static DateTimeOffset ReadValue <TInput>(ref Reader <TInput> reader, Field field) { ReferenceCodec.MarkValueField(reader.Session); if (field.WireType != WireType.TagDelimited) { ThrowUnsupportedWireTypeException(field); } uint fieldId = 0; TimeSpan offset = default; DateTime dateTime = default; while (true) { var header = reader.ReadFieldHeader(); if (header.IsEndBaseOrEndObject) { break; } fieldId += header.FieldIdDelta; switch (fieldId) { case 0: dateTime = DateTimeCodec.ReadValue(ref reader, header); break; case 1: offset = TimeSpanCodec.ReadValue(ref reader, header); break; default: reader.ConsumeUnknownField(header); break; } } return(new DateTimeOffset(dateTime, offset)); }
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 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)); } }
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, byte value) where TBufferWriter : IBufferWriter <byte> { ReferenceCodec.MarkValueField(writer.Session); writer.WriteFieldHeader(fieldIdDelta, expectedType, typeof(byte), WireType.VarInt); writer.WriteVarInt(value); }
public static char ReadValue(ref Reader reader, Field field) { ReferenceCodec.MarkValueField(reader.Session); return((char)reader.ReadUInt16(field.WireType)); }
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); }
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 object ReadValue(Reader reader, SerializerSession session, Field field) { ReferenceCodec.MarkValueField(session); reader.SkipField(session, field); return(null); }
public void WriteField(Writer writer, SerializerSession session, uint fieldIdDelta, Type expectedType, object value) { ReferenceCodec.MarkValueField(session); throw new NotImplementedException(); }