/// <summary> /// Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed /// data - useful with network IO. /// </summary> /// <param name="type">The type being merged.</param> /// <param name="value">The existing instance to be modified (can be null).</param> /// <param name="source">The binary stream to apply to the instance (cannot be null).</param> /// <param name="style">How to encode the length prefix.</param> /// <param name="expectedField">The tag used as a prefix to each record (only used with base-128 style prefixes).</param> /// <param name="resolver">Used to resolve types on a per-field basis.</param> /// <param name="bytesRead">Returns the number of bytes consumed by this operation (includes length-prefix overheads and any skipped data).</param> /// <returns>The updated instance; this may be different to the instance argument if /// either the original instance was null, or the stream defines a known sub-type of the /// original instance.</returns> public object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, out int bytesRead) { bool skip; int len; int tmpBytesRead; bytesRead = 0; do { int actualField; bool expectPrefix = expectedField > 0 || resolver != null; len = ProtoReader.ReadLengthPrefix(source, expectPrefix, style, out actualField, out tmpBytesRead); bytesRead += tmpBytesRead; if (len < 0) { return(value); } if (expectedField == 0 && type == null && resolver != null) { type = resolver(actualField); skip = type == null; } else { skip = expectedField != actualField; } if (skip) { if (len == int.MaxValue) { throw new InvalidOperationException(); } ProtoReader.Seek(source, len, null); bytesRead += len; } } while (skip); int key = GetKey(ref type); if (key < 0) { throw new InvalidOperationException(); } using (ProtoReader reader = new ProtoReader(source, this, len)) { object result = Deserialize(key, value, reader); bytesRead += reader.Position; return(result); } }
private object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, out int bytesRead, out bool haveObject, SerializationContext context) { haveObject = false; bytesRead = 0; if (type == null && (style != PrefixStyle.Base128 || resolver == null)) { throw new InvalidOperationException("A type must be provided unless base-128 prefixing is being used in combination with a resolver"); } while (true) { bool expectPrefix = expectedField > 0 || resolver != null; int actualField; int tmpBytesRead; int len = ProtoReader.ReadLengthPrefix(source, expectPrefix, style, out actualField, out tmpBytesRead); if (tmpBytesRead == 0) { break; } bytesRead += tmpBytesRead; if (len < 0) { return(value); } bool skip; if (style == PrefixStyle.Base128) { if (expectPrefix && expectedField == 0 && type == null && resolver != null) { type = resolver(actualField); skip = (type == null); } else { skip = (expectedField != actualField); } } else { skip = false; } if (skip) { if (len == 2147483647) { goto Block_12; } ProtoReader.Seek(source, len, null); bytesRead += len; } if (!skip) { goto Block_13; } } return(value); Block_12: throw new InvalidOperationException(); Block_13: ProtoReader reader = null; object result; try { int len; reader = ProtoReader.Create(source, this, context, len); int key = this.GetKey(ref type); if (key >= 0 && !Helpers.IsEnum(type)) { value = this.Deserialize(key, value, reader); } else { if (!this.TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, true, false, true, false) && len != 0) { TypeModel.ThrowUnexpectedType(type); } } bytesRead += reader.Position; haveObject = true; result = value; } finally { ProtoReader.Recycle(reader); } return(result); }
private object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, Serializer.TypeResolver resolver, out int bytesRead, out bool haveObject, SerializationContext context) { haveObject = false; bytesRead = 0; if (type == null && (style != PrefixStyle.Base128 || resolver == null)) { throw new InvalidOperationException("A type must be provided unless base-128 prefixing is being used in combination with a resolver"); } int num; bool flag2; do { bool flag = expectedField > 0 || resolver != null; num = ProtoReader.ReadLengthPrefix(source, flag, style, out int fieldNumber, out int bytesRead2); if (bytesRead2 == 0) { return(value); } bytesRead += bytesRead2; if (num < 0) { return(value); } if (style == PrefixStyle.Base128) { if (flag && expectedField == 0 && type == null && resolver != null) { type = resolver(fieldNumber); flag2 = (type == null); } else { flag2 = (expectedField != fieldNumber); } } else { flag2 = false; } if (flag2) { if (num == int.MaxValue) { throw new InvalidOperationException(); } ProtoReader.Seek(source, num, null); bytesRead += num; } }while (flag2); ProtoReader protoReader = null; try { protoReader = ProtoReader.Create(source, this, context, num); int key = GetKey(ref type); if (key >= 0 && !Helpers.IsEnum(type)) { value = Deserialize(key, value, protoReader); } else if (!TryDeserializeAuxiliaryType(protoReader, DataFormat.Default, 1, type, ref value, skipOtherFields: true, asListItem: false, autoCreate: true, insideList: false) && num != 0) { ThrowUnexpectedType(type); } bytesRead += protoReader.Position; haveObject = true; return(value); } finally { ProtoReader.Recycle(protoReader); } }
private object DeserializeWithLengthPrefix(Stream source, object value, Type type, PrefixStyle style, int expectedField, ProtobufSerializer.TypeResolver resolver, out int bytesRead, out bool haveObject, SerializationContext context) { bool flag; int num; haveObject = false; bytesRead = 0; if ((type == null) && ((style != PrefixStyle.Base128) || (resolver == null))) { throw new InvalidOperationException("A type must be provided unless base-128 prefixing is being used in combination with a resolver"); } do { int num2; int num3; bool expectHeader = (expectedField > 0) || (resolver != null); num = ProtoReader.ReadLengthPrefix(source, expectHeader, style, out num3, out num2); if (num2 == 0) { return(value); } bytesRead += num2; if (num < 0) { return(value); } if (style == PrefixStyle.Base128) { if ((expectHeader && (expectedField == 0)) && ((type == null) && (resolver != null))) { type = resolver(num3); flag = type == null; } else { flag = expectedField != num3; } } else { flag = false; } if (flag) { if (num == 0x7fffffff) { throw new InvalidOperationException(); } ProtoReader.Seek(source, num, null); bytesRead += num; } }while (flag); using (ProtoReader reader = new ProtoReader(source, this, context, num)) { int key = this.GetKey(ref type); if ((key >= 0) && !Helpers.IsEnum(type)) { value = this.Deserialize(key, value, reader); } else if (!this.TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, true, false, true, false) && (num != 0)) { ThrowUnexpectedType(type); } bytesRead += reader.Position; haveObject = true; return(value); } }