Timestamp ISerializer <Timestamp> .Read(ref ProtoReader.State state, Timestamp value) { var duration = new Duration(value.Seconds, value.Nanoseconds); duration = ReadDuration(ref state, duration); return(new Timestamp(duration.Seconds, duration.Nanoseconds)); }
public KeyValuePair <TKey, TValue> Read(ref ProtoReader.State state, KeyValuePair <TKey, TValue> pair) { TKey key = pair.Key; TValue value = pair.Value; int field; while ((field = state.ReadFieldHeader()) > 0) { switch (field) { case 1: key = state.ReadAny(_keyFeatures, key, _keySerializer); break; case 2: value = state.ReadAny(_valueFeatures, value, _valueSerializer); break; default: state.SkipField(); break; } } if (TypeHelper <TKey> .IsReferenceType && TypeHelper <TKey> .ValueChecker.IsNull(key)) { key = TypeModel.CreateInstance <TKey>(state.Context, _keySerializer); } if (TypeHelper <TValue> .IsReferenceType && TypeHelper <TValue> .ValueChecker.IsNull(value)) { value = TypeModel.CreateInstance <TValue>(state.Context, _valueSerializer); } return(new KeyValuePair <TKey, TValue>(key, value)); }
public void Deserialize(ProtoReader reader, ref ProtoReader.State state, ref T obj) { object o = obj; o = deserializer(reader, ref state, o); obj = (T)o; }
public override object Read(ProtoReader source, ref ProtoReader.State state, object value) { int field = source.FieldNumber; BasicList list = new BasicList(); if (packedWireType != WireType.None && source.WireType == WireType.String) { SubItemToken token = ProtoReader.StartSubItem(source, ref state); while (ProtoReader.HasSubValue(packedWireType, source)) { list.Add(Tail.Read(source, ref state, null)); } ProtoReader.EndSubItem(token, source, ref state); } else { do { list.Add(Tail.Read(source, ref state, null)); } while (source.TryReadFieldHeader(ref state, field)); } int oldLen = AppendToCollection ? (value == null ? 0 : ((Array)value).Length) : 0; Array result = Array.CreateInstance(itemType, oldLen + list.Count); if (oldLen != 0) { ((Array)value).CopyTo(result, 0); } list.CopyTo(result, oldLen); return(result); }
decimal ISerializer <decimal> .Read(ref ProtoReader.State state, decimal value) { ulong low = 0; uint high = 0; uint signScale = 0; int fieldNumber; while ((fieldNumber = state.ReadFieldHeader()) > 0) { switch (fieldNumber) { case FieldDecimalLow: low = state.ReadUInt64(); break; case FieldDecimalHigh: high = state.ReadUInt32(); break; case FieldDecimalSignScale: signScale = state.ReadUInt32(); break; default: state.SkipField(); break; } } int lo = (int)(low & 0xFFFFFFFFL), mid = (int)((low >> 32) & 0xFFFFFFFFL), hi = (int)high; bool isNeg = (signScale & 0x0001) == 0x0001; byte scale = (byte)((signScale & 0x01FE) >> 1); return(new decimal(lo, mid, hi, isNeg, scale)); }
LocalDate ISerializer <LocalDate> .Read(ref ProtoReader.State state, LocalDate value) { int field; int year = value.Year, month = value.Month, day = value.Day; while ((field = state.ReadFieldHeader()) > 0) { switch (field) { case 1: year = state.ReadInt32(); break; case 2: month = state.ReadInt32(); break; case 3: day = state.ReadInt32(); break; default: state.SkipField(); break; } } return(new LocalDate(year, month, day)); // ISO calendar is implicit }
LocalTime ISerializer <LocalTime> .Read(ref ProtoReader.State state, LocalTime value) { int field; int hours = value.Hour, minutes = value.Minute, seconds = value.Second, nanos = value.NanosecondOfSecond; while ((field = state.ReadFieldHeader()) > 0) { switch (field) { case 1: hours = state.ReadInt32(); break; case 2: minutes = state.ReadInt32(); break; case 3: seconds = state.ReadInt32(); break; case 4: nanos = state.ReadInt32(); break; default: state.SkipField(); break; } } return(new LocalTime(hours, minutes, seconds).PlusNanoseconds(nanos)); }
public object Read(ref ProtoReader.State state, object value) { object[] values = new object[members.Length]; bool invokeCtor = false; if (value == null) { invokeCtor = true; } for (int i = 0; i < values.Length; i++) { values[i] = GetValue(value, i); } int field; while ((field = state.ReadFieldHeader()) > 0) { invokeCtor = true; if (field <= tails.Length) { IRuntimeProtoSerializerNode tail = tails[field - 1]; values[field - 1] = tails[field - 1].Read(ref state, tail.RequiresOldValue ? values[field - 1] : null); } else { state.SkipField(); } } return(invokeCtor ? ctor.Invoke(values) : value); }
internal static Timestamp ReadTimestamp(ref ProtoReader.State state, Timestamp value) { var duration = new Duration(value.Seconds, value.Nanoseconds); duration = ReadDuration(ref state, duration); return(new Timestamp(duration.Seconds, duration.Nanoseconds)); }
public override object Read(ref ProtoReader.State state, object value) { Debug.Assert(value is null); // not expecting incoming string s = (string)Tail.Read(ref state, null); return(s.Length == 0 ? null : new Uri(s, UriKind.RelativeOrAbsolute)); }
public override object Read(ref ProtoReader.State state, object value) { var ss = (SubTypeState <TParent>)value; ss.ReadSubType <TChild>(ref state); return(ss); }
public override object Read(ProtoReader source, ref ProtoReader.State state, object value) { TDictionary typed = (AppendToCollection ? ((TDictionary)value) : null) ?? (TDictionary)Activator.CreateInstance(concreteType); do { var key = DefaultKey; var typedValue = DefaultValue; SubItemToken token = ProtoReader.StartSubItem(source, ref state); int field; while ((field = source.ReadFieldHeader(ref state)) > 0) { switch (field) { case 1: key = (TKey)keyTail.Read(source, ref state, null); break; case 2: typedValue = (TValue)Tail.Read(source, ref state, Tail.RequiresOldValue ? (object)typedValue : null); break; default: source.SkipField(ref state); break; } } ProtoReader.EndSubItem(token, source, ref state); typed[key] = typedValue; } while (source.TryReadFieldHeader(ref state, fieldNumber)); return(typed); }
private static void Merge(ProtoReader reader, ref ProtoReader.State state, ref protogen.Database obj) { SubItemToken tok; int field; if (obj == null) { obj = new protogen.Database(); } while ((field = reader.ReadFieldHeader(ref state)) != 0) { switch (field) { case 1: do { protogen.Order _1 = default; tok = ProtoReader.StartSubItem(reader, ref state); Merge(reader, ref state, ref _1); ProtoReader.EndSubItem(tok, reader, ref state); obj.Orders.Add(_1); } while (reader.TryReadFieldHeader(ref state, 1)); break; default: reader.AppendExtensionData(ref state, obj); break; } } }
public static List <Student> CreateProtoReaderBuffer(byte[] encoded) { using (MemoryStream rs = new MemoryStream(encoded)) { ProtoReader.State pr = ProtoReader.State.Create(rs, null, null); List <Student> students = new List <Student>(); Student student = new Student(); while (pr.GetPosition() < rs.Length) { var fieldHeader = pr.ReadFieldHeader(); if (fieldHeader == 1) { student = new Student(); students.Add(student); } if (fieldHeader == 1) { student.Id = BclHelpers.ReadGuid(ref pr); } else if (fieldHeader == 2) { student.Name = pr.ReadString(); } else if (fieldHeader == 3) { student.AdmissionDate = BclHelpers.ReadDateTime(ref pr); } else if (fieldHeader == 4) { student.Age = pr.ReadInt32(); } } return(students); } }
private static Duration ReadDurationFallback(ref ProtoReader.State state, Duration value) { var seconds = value.Seconds; var nanos = value.Nanoseconds; int fieldNumber; while ((fieldNumber = state.ReadFieldHeader()) > 0) { switch (fieldNumber) { case 1: seconds = state.ReadInt64(); break; case 2: nanos = state.ReadInt32(); break; default: state.SkipField(); break; } } return(new Duration(seconds, nanos)); }
public ProtoReader ReadROM(out ProtoReader.State state) { if (!_ros.IsSingleSegment) { throw new InvalidOperationException("Expected single segment"); } return(ProtoReader.Create(out state, _ros.First, Model)); }
T ISubTypeSerializer <T> .ReadSubType(ref ProtoReader.State state, SubTypeState <T> value) { value.OnBeforeDeserialize(_subTypeOnBeforeDeserialize); DeserializeBody(ref state, ref value, (ref SubTypeState <T> s) => s.Value, (ref SubTypeState <T> s, T v) => s.Value = v); var val = value.Value; Callback(ref val, TypeModel.CallbackType.AfterDeserialize, state.Context); return(val); }
public override object Read(ProtoReader source, ref ProtoReader.State state, object value) { object result = Tail.Read(source, ref state, value); if (setSpecified != null) { setSpecified.Invoke(value, new object[] { true }); } return(result); }
public object Read(ProtoReader source, ref ProtoReader.State state, object value) { // convert the incoming value object[] args = { value }; value = toTail.Invoke(null, args); // invoke the tail and convert the outgoing value args[0] = rootTail.Read(source, ref state, value); return(fromTail.Invoke(null, args)); }
internal static Duration ReadDuration(ref ProtoReader.State state, Duration value) { if (state.WireType == WireType.String && state.RemainingInCurrent >= 20) { if (TryReadDurationFast(ref state, ref value)) { return(value); } } return(ReadDurationFallback(ref state, value)); }
public override object Read(ref ProtoReader.State state, object value) { Debug.Assert(value != null); object newValue = Tail.Read(ref state, Tail.RequiresOldValue ? field.GetValue(value) : null); if (newValue != null) { field.SetValue(value, newValue); } return(null); }
public object Read(ProtoReader source, ref ProtoReader.State state, object value) { if (wellKnown) { return(BclHelpers.ReadDuration(source, ref state)); } else { Helpers.DebugAssert(value == null); // since replaces return(BclHelpers.ReadTimeSpan(source, ref state)); } }
public object Read(ref ProtoReader.State state, object value) { if (wellKnown) { return(BclHelpers.ReadTimestamp(ref state)); } else { Debug.Assert(value == null); // since replaces return(BclHelpers.ReadDateTime(ref state)); } }
public override object Read(ProtoReader source, ref ProtoReader.State state, object value) { Helpers.DebugAssert(fieldNumber == source.FieldNumber); if (strict) { source.Assert(ref state, wireType); } else if (NeedsHint) { source.Hint(wireType); } return(Tail.Read(source, ref state, value)); }
T ISerializer <T> .Read(ref ProtoReader.State state, T value) { bool isFirst = Interlocked.Increment(ref _deserializeCount) == 1; if (isFirst) { RuntimeTypeModel.OnDebugLog("Pre first read", typeof(T)); } value = state.ReadBaseType <TBase, T>(value); if (isFirst) { RuntimeTypeModel.OnDebugLog("Post first read", typeof(T)); } return(value); }
public override object Read(ref ProtoReader.State state, object value) { bool isFirst = Interlocked.Increment(ref _deserializeCount) == 1; if (isFirst) { RuntimeTypeModel.OnDebugLog("Pre first read", typeof(T)); } value = state.ReadBaseType <TBase, T>(TypeHelper <T> .FromObject(value)); if (isFirst) { RuntimeTypeModel.OnDebugLog("Post first read", typeof(T)); } return(value); }
T ISubTypeSerializer <T> .ReadSubType(ref ProtoReader.State state, SubTypeState <T> value) { bool isFirst = Interlocked.Increment(ref _subDeserializeCount) == 1; if (isFirst) { RuntimeTypeModel.OnDebugLog("Pre first sub-read", typeof(T)); } var ret = subTypeDeserializer(ref state, value); if (isFirst) { RuntimeTypeModel.OnDebugLog("Pre first sub-read", typeof(T)); } return(ret); }
internal static unsafe Guid Read(ref ProtoReader.State state) { // note: we can't use a stackalloc-span here because the compiler doesn't trust // state, which is a ref-local (and can store spans), not to store it; since we *don't* // do that, we can be evil byte *ptr = stackalloc byte[MAX_LENGTH]; var available = state.ReadBytes(new Span <byte>(ptr, MAX_LENGTH)); char standardFormat; switch (available.Length) { case 0: return(Guid.Empty); case 16: // treat as big-endian bytes // expand those bytes to hex, backwards so we don't overwrite live data int write = 32; for (int i = 15; i >= 0; i--) { var val = ptr[i]; ptr[--write] = ToHex(val & 0b1111); ptr[--write] = ToHex((val >> 4) & 0b1111); } available = new Span <byte>(ptr, 32); standardFormat = 'N'; break; case 32: // no hyphens standardFormat = 'N'; break; case 36: // hyphens standardFormat = 'D'; break; default: ThrowHelper.Format($"Unexpected Guid length: {available.Length}"); return(default); } if (!(Utf8Parser.TryParse(available, out Guid guid, out int bytes, standardFormat) && bytes == available.Length)) { ThrowHelper.Format($"Failed to read Guid: '{Encoding.UTF8.GetString(ptr, available.Length)}'"); } return(guid);
public MyMessage Read(ref ProtoReader.State state, MyMessage value) { value ??= new MyMessage(); int field; while ((field = state.ReadFieldHeader()) > 0) { switch (field) { case 12: value.Y = state.ReadString(); break; case 42: value.X = state.ReadInt32(); break; default: state.SkipField(); break; } } return(value); }
public override object Read(ref ProtoReader.State state, object value) { var category = GetCategory(); switch (category) { case SerializerFeatures.CategoryMessageWrappedAtRoot: case SerializerFeatures.CategoryMessage: return(state.ReadMessage <T>(default, TypeHelper <T> .FromObject(value), CustomSerializer)); case SerializerFeatures.CategoryScalar: return(CustomSerializer.Read(ref state, TypeHelper <T> .FromObject(value))); default: category.ThrowInvalidCategory(); return(default); } }