private Dictionary <TKey, TValue> CreateInstance(IEqualityComparer <TKey> comparer, SerializerSession session, uint placeholderReferenceId)
{
var result = this.activator.Create(comparer);
ReferenceCodec.RecordObject(session, result, placeholderReferenceId);
return(result);
}
public static string ReadValue(ref Reader reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <string>(ref reader, field));
}
if (field.WireType != WireType.LengthPrefixed)
{
ThrowUnsupportedWireTypeException(field);
}
var length = reader.ReadVarUInt32();
string result;
#if NETCOREAPP2_1
if (reader.TryReadBytes((int)length, out var span))
{
result = Encoding.UTF8.GetString(span);
}
else
#endif
{
var bytes = reader.ReadBytes(length);
result = Encoding.UTF8.GetString(bytes);
}
ReferenceCodec.RecordObject(reader.Session, result);
return(result);
}
public TField ReadValue <TInput>(ref Reader <TInput> reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <TField, TInput>(ref reader, field));
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session);
var fieldType = field.FieldType;
if (fieldType is null || fieldType == CodecFieldType)
{
TSurrogate surrogate = default;
_surrogateSerializer.Deserialize(ref reader, ref surrogate);
var result = ConvertFromSurrogate(ref surrogate);
ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId);
return(result);
}
// The type is a descendant, not an exact match, so get the specific serializer for it.
var specificSerializer = reader.Session.CodecProvider.GetCodec(fieldType);
if (specificSerializer != null)
{
return((TField)specificSerializer.ReadValue(ref reader, field));
}
ThrowSerializerNotFoundException(fieldType);
return(null);
}
public T[] ReadValue <TInput>(ref Reader <TInput> reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <T[], TInput>(ref reader, field));
}
if (field.WireType != WireType.TagDelimited)
{
ThrowUnsupportedWireTypeException(field);
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session);
T[] result = null;
uint fieldId = 0;
var length = 0;
var index = 0;
while (true)
{
var header = reader.ReadFieldHeader();
if (header.IsEndBaseOrEndObject)
{
break;
}
fieldId += header.FieldIdDelta;
switch (fieldId)
{
case 0:
length = Int32Codec.ReadValue(ref reader, header);
result = new T[length];
ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId);
break;
case 1:
if (result is null)
{
return(ThrowLengthFieldMissing());
}
if (index >= length)
{
return(ThrowIndexOutOfRangeException(length));
}
result[index] = _fieldCodec.ReadValue(ref reader, header);
++index;
break;
default:
reader.ConsumeUnknownField(header);
break;
}
}
return(result);
}
List <T> IFieldCodec <List <T> > .ReadValue <TInput>(ref Reader <TInput> reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <List <T>, TInput>(ref reader, field));
}
if (field.WireType != WireType.TagDelimited)
{
ThrowUnsupportedWireTypeException(field);
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session);
List <T> result = null;
uint fieldId = 0;
var length = 0;
var index = 0;
while (true)
{
var header = reader.ReadFieldHeader();
if (header.IsEndBaseOrEndObject)
{
break;
}
fieldId += header.FieldIdDelta;
switch (fieldId)
{
case 0:
length = Int32Codec.ReadValue(ref reader, header);
result = _activator.Create(length);
result.Capacity = length;
ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId);
break;
case 1:
if (result is null)
{
ThrowLengthFieldMissing();
}
if (index >= length)
{
ThrowIndexOutOfRangeException(length);
}
// ReSharper disable once PossibleNullReferenceException
result.Add(_fieldCodec.ReadValue(ref reader, header));
++index;
break;
default:
reader.ConsumeUnknownField(header);
break;
}
}
return(result);
}
public List <T> ReadValue(Reader reader, SerializerSession session, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <List <T> >(reader, session, field, this.codecProvider));
}
if (field.WireType != WireType.TagDelimited)
{
ThrowUnsupportedWireTypeException(field);
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(session);
List <T> result = null;
uint fieldId = 0;
var length = 0;
var index = 0;
while (true)
{
var header = reader.ReadFieldHeader(session);
if (header.IsEndBaseOrEndObject)
{
break;
}
fieldId += header.FieldIdDelta;
switch (fieldId)
{
case 0:
length = this.intCodec.ReadValue(reader, session, header);
result = this.activator.Create(length);
result.Capacity = length;
ReferenceCodec.RecordObject(session, result, placeholderReferenceId);
break;
case 1:
if (result == null)
{
ThrowLengthFieldMissing();
}
if (index >= length)
{
ThrowIndexOutOfRangeException(length);
}
// ReSharper disable once PossibleNullReferenceException
result.Add(this.fieldCodec.ReadValue(reader, session, header));
++index;
break;
default:
reader.ConsumeUnknownField(session, header);
break;
}
}
return(result);
}
/// <summary>
/// Consumes an unknown field.
/// </summary>
public static void ConsumeUnknownField(this Reader reader, SerializerSession session, Field field)
{
// References cannot themselves be referenced.
if (field.WireType == WireType.Reference)
{
reader.ReadVarUInt32();
return;
}
// Record a placeholder so that this field can later be correctly deserialized if it is referenced.
ReferenceCodec.RecordObject(session, new UnknownFieldMarker(field, reader.CurrentPosition));
// TODO: Advance the reader without actually reading bytes / allocating.
switch (field.WireType)
{
case WireType.VarInt:
reader.ReadVarUInt64();
break;
case WireType.TagDelimited:
// Since tag delimited fields can be comprised of other fields, recursively consume those, too.
ConsumeTagDelimitedField(reader, session);
break;
case WireType.LengthPrefixed:
SkipFieldExtension.SkipLengthPrefixedField(reader);
break;
case WireType.Fixed32:
reader.ReadUInt();
break;
case WireType.Fixed64:
reader.ReadULong();
break;
case WireType.Fixed128:
reader.ReadULong();
reader.ReadULong();
break;
case WireType.Extended:
SkipFieldExtension.ThrowUnexpectedExtendedWireType(field);
break;
default:
SkipFieldExtension.ThrowUnexpectedWireType(field);
break;
}
}
public TField ReadValue <TInput>(ref Reader <TInput> reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <TField, TInput>(ref reader, field));
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session);
TSurrogate surrogate = default;
_surrogateSerializer.Deserialize(ref reader, ref surrogate);
var result = ConvertFromSurrogate(ref surrogate);
ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId);
return(result);
}
public static byte[] ReadValue(ref Reader reader, SerializerSession session, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <byte[]>(ref reader, session, field));
}
if (field.WireType != WireType.LengthPrefixed)
{
ThrowUnsupportedWireTypeException(field);
}
var length = reader.ReadVarUInt32();
var result = reader.ReadBytes(length);
ReferenceCodec.RecordObject(session, result);
return(result);
}
byte[] IFieldCodec <byte[]> .ReadValue(Reader reader, SerializerSession session, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <byte[]>(reader, session, field, this.codecProvider));
}
if (field.WireType != WireType.LengthPrefixed)
{
ThrowUnsupportedWireTypeException(field);
}
var length = reader.ReadVarUInt32();
var result = reader.ReadBytes((int)length);
ReferenceCodec.RecordObject(session, result);
return(result);
}
public static object ReadValue(ref Reader reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <object>(ref reader, field));
}
if (field.FieldType == ObjectType || field.FieldType == null)
{
reader.ReadVarUInt32();
var result = new object();
ReferenceCodec.RecordObject(reader.Session, result);
return(result);
}
var specificSerializer = reader.Session.CodecProvider.GetCodec(field.FieldType);
return(specificSerializer.ReadValue(ref reader, field));
}
Tuple <T> IFieldCodec <Tuple <T> > .ReadValue <TInput>(ref Reader <TInput> reader, Field field)
{
if (field.WireType == WireType.Reference)
{
return(ReferenceCodec.ReadReference <Tuple <T>, TInput>(ref reader, field));
}
if (field.WireType != WireType.TagDelimited)
{
ThrowUnsupportedWireTypeException(field);
}
var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session);
var item1 = default(T);
uint fieldId = 0;
while (true)
{
var header = reader.ReadFieldHeader();
if (header.IsEndBaseOrEndObject)
{
break;
}
fieldId += header.FieldIdDelta;
switch (fieldId)
{
case 1:
item1 = _valueCodec.ReadValue(ref reader, header);
break;
default:
reader.ConsumeUnknownField(header);
break;
}
}
var result = new Tuple <T>(item1);
ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId);
return(result);
}
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 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);
}
