/// <inheritdoc/> 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 Dictionary <TKey, TValue> ReadValue <TInput>(ref Reader <TInput> reader, Field field) { if (field.WireType == WireType.Reference) { return(ReferenceCodec.ReadReference <Dictionary <TKey, TValue>, TInput>(ref reader, field)); } if (field.WireType != WireType.TagDelimited) { ThrowUnsupportedWireTypeException(field); } var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session); int length = 0; Dictionary <TKey, TValue> result = null; IEqualityComparer <TKey> comparer = null; uint fieldId = 0; while (true) { var header = reader.ReadFieldHeader(); if (header.IsEndBaseOrEndObject) { break; } fieldId += header.FieldIdDelta; switch (fieldId) { case 0: comparer = _comparerCodec.ReadValue(ref reader, header); break; case 1: length = Int32Codec.ReadValue(ref reader, header); if (length > 10240 && length > reader.Length) { ThrowInvalidSizeException(length); } break; case 2: result ??= CreateInstance(length, comparer, reader.Session, placeholderReferenceId); var pair = _pairCodec.ReadValue(ref reader, header); result.Add(pair.Key, pair.Value); break; default: reader.ConsumeUnknownField(header); break; } } result ??= CreateInstance(length, comparer, reader.Session, placeholderReferenceId); return(result); }
/// <inheritdoc/> Queue <T> IFieldCodec <Queue <T> > .ReadValue <TInput>(ref Reader <TInput> reader, Field field) { if (field.WireType == WireType.Reference) { return(ReferenceCodec.ReadReference <Queue <T>, TInput>(ref reader, field)); } if (field.WireType != WireType.TagDelimited) { ThrowUnsupportedWireTypeException(field); } var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session); Queue <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 Queue <T>(length); ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId); break; case 1: if (result is null) { ThrowLengthFieldMissing(); } if (index >= length) { ThrowIndexOutOfRangeException(length); } result.Enqueue(_fieldCodec.ReadValue(ref reader, header)); ++index; break; default: reader.ConsumeUnknownField(header); break; } } 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); TSurrogate surrogate = default; _surrogateSerializer.Deserialize(ref reader, ref surrogate); var result = ConvertFromSurrogate(ref surrogate); ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId); return(result); }
/// <inheritdoc/> public CompareInfo ReadValue <TInput>(ref Reader <TInput> reader, Field field) { if (field.WireType == WireType.Reference) { return(ReferenceCodec.ReadReference <CompareInfo, TInput>(ref reader, field)); } if (field.WireType != WireType.TagDelimited) { ThrowUnsupportedWireTypeException(field); } var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session); uint fieldId = 0; string name = null; while (true) { var header = reader.ReadFieldHeader(); if (header.IsEndBaseOrEndObject) { break; } fieldId += header.FieldIdDelta; switch (fieldId) { case 0: name = StringCodec.ReadValue(ref reader, header); break; case 1: break; default: reader.ConsumeUnknownField(header); break; } } var result = CompareInfo.GetCompareInfo(name); ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId); return(result); }
public static IPEndPoint ReadValue <TInput>(ref Buffers.Reader <TInput> reader, Field field) { if (field.WireType == WireType.Reference) { return((IPEndPoint)ReferenceCodec.ReadReference(ref reader, field, CodecFieldType)); } var referencePlaceholder = ReferenceCodec.CreateRecordPlaceholder(reader.Session); IPAddress address = default; ushort port = 0; int id = 0; Field header = default; while (true) { id = OrleansGeneratedCodeHelper.ReadHeader(ref reader, ref header, id); if (id == 1) { address = IPAddressCodec.ReadValue(ref reader, header); id = OrleansGeneratedCodeHelper.ReadHeader(ref reader, ref header, id); } if (id == 2) { port = UInt16Codec.ReadValue(ref reader, header); id = OrleansGeneratedCodeHelper.ReadHeaderExpectingEndBaseOrEndObject(ref reader, ref header, id); } if (id != -1) { reader.ConsumeUnknownField(header); } else { break; } } var result = new IPEndPoint(address, port); ReferenceCodec.RecordObject(reader.Session, result, referencePlaceholder); return(result); }
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(); } 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); }
/// <inheritdoc/> object IFieldCodec <object> .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); Array result = null; uint fieldId = 0; int[] lengths = null; int[] indices = null; var rank = 0; while (true) { var header = reader.ReadFieldHeader(); if (header.IsEndBaseOrEndObject) { break; } fieldId += header.FieldIdDelta; switch (fieldId) { case 0: { lengths = _intArrayCodec.ReadValue(ref reader, header); rank = lengths.Length; // Multi-dimensional arrays must be indexed using indexing arrays, so create one now. indices = new int[rank]; result = Array.CreateInstance(CodecElementType, lengths); ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId); break; } case 1: { if (result is null) { return(ThrowLengthsFieldMissing()); } var element = _elementCodec.ReadValue(ref reader, 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(header); break; } } return(result); }
/// <summary> /// Reads a value. /// </summary> /// <typeparam name="TInput">The reader input type.</typeparam> /// <param name="reader">The reader.</param> /// <param name="field">The field.</param> /// <returns>The value.</returns> public static Type ReadValue <TInput>(ref Reader <TInput> reader, Field field) { if (field.WireType == WireType.Reference) { return(ReferenceCodec.ReadReference <Type, TInput>(ref reader, field)); } var placeholderReferenceId = ReferenceCodec.CreateRecordPlaceholder(reader.Session); 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.ReadLengthPrefixed(ref reader); break; case 2: id = reader.ReadVarUInt32(); break; default: reader.ConsumeUnknownField(header); break; } } switch (schemaType) { case SchemaType.Referenced: if (reader.Session.ReferencedTypes.TryGetReferencedType(id, out result)) { break; } return(ThrowUnknownReferencedType(id)); case SchemaType.WellKnown: if (reader.Session.WellKnownTypes.TryGetWellKnownType(id, out result)) { break; } return(ThrowUnknownWellKnownType(id)); case SchemaType.Encoded: if (result is not null) { break; } return(ThrowMissingType()); default: return(ThrowInvalidSchemaType(schemaType)); } ReferenceCodec.RecordObject(reader.Session, result, placeholderReferenceId); return(result); }