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