public static void AppendExtensionData(IExtensible instance, ProtoWriter writer) { if (instance == null) { throw new ArgumentNullException("instance"); } if (writer == null) { throw new ArgumentNullException("writer"); } if (writer.wireType != WireType.None) { throw ProtoWriter.CreateException(writer); } IExtension extn = instance.GetExtensionObject(false); if (extn != null) { Stream source = extn.BeginQuery(); try { ProtoWriter.CopyRawFromStream(source, writer); } finally { extn.EndQuery(source); } } }
internal static void AppendExtendValue <TValue>(TypeModel model, IExtensible instance, int tag, DataFormat format, object value) { if (instance == null) { throw new ArgumentNullException("instance"); } if (value == null) { throw new ArgumentNullException("value"); } //TODO: CheckTagNotInUse //model.CheckTagNotInUse(tag); // obtain the extension object and prepare to write IExtension extn = instance.GetExtensionObject(true); if (extn == null) { throw new InvalidOperationException("No extension object available; appended data would be lost."); } bool commit = false; Stream stream = extn.BeginAppend(); try { using (ProtoWriter writer = new ProtoWriter(stream, model, null)) { model.TrySerializeAuxiliaryType(writer, null, format, tag, value, false); writer.Close(); } commit = true; } finally { extn.EndAppend(stream, commit); } }
/// <summary> /// Copies any extension data stored for the instance to the underlying stream /// </summary> public static void AppendExtensionData(IExtensible instance, ProtoWriter writer) { if (instance == null) { throw new ArgumentNullException("instance"); } if (writer == null) { throw new ArgumentNullException("writer"); } // we expect the writer to be raw here; the extension data will have the // header detail, so we'll copy it implicitly if (writer.wireType != WireType.None) { throw CreateException(writer); } IExtension extn = instance.GetExtensionObject(false); if (extn != null) { // unusually we *don't* want "using" here; the "finally" does that, with // the extension object being responsible for disposal etc Stream source = extn.BeginQuery(); try { CopyRawFromStream(source, writer); } finally { extn.EndQuery(source); } } }
public static void AppendExtensionData(IExtensible instance, ProtoWriter writer) { if (instance == null) { throw new ArgumentNullException("instance"); } if (writer == null) { throw new ArgumentNullException("writer"); } if (writer.wireType != WireType.None) { throw CreateException(writer); } IExtension extensionObject = instance.GetExtensionObject(createIfMissing: false); if (extensionObject != null) { Stream stream = extensionObject.BeginQuery(); try { CopyRawFromStream(stream, writer); } finally { extensionObject.EndQuery(stream); } } }
public void AppendExtendValue(TypeModel model, IExtensible instance, int tag, BinaryDataFormat format, object value) { #if FEAT_IKVM throw new NotSupportedException(); #else if (instance == null) { throw new ArgumentNullException(nameof(instance)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } // obtain the extension object and prepare to write IExtension extn = instance.GetExtensionObject(true); if (extn == null) { throw new InvalidOperationException("No extension object available; appended data would be lost."); } bool commit = false; Stream stream = extn.BeginAppend(); try { using (ProtoWriter writer = new ProtoWriter(stream, model, null)) { model.TrySerializeAuxiliaryType(writer, null, format, tag, value, false, true); writer.Close(); } commit = true; } finally { extn.EndAppend(stream, commit); } #endif }
// Token: 0x06003293 RID: 12947 RVA: 0x00127460 File Offset: 0x00125860 internal static void AppendExtendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value) { if (instance == null) { throw new ArgumentNullException("instance"); } if (value == null) { throw new ArgumentNullException("value"); } IExtension extensionObject = instance.GetExtensionObject(true); if (extensionObject == null) { throw new InvalidOperationException("No extension object available; appended data would be lost."); } bool commit = false; Stream stream = extensionObject.BeginAppend(); try { using (ProtoWriter protoWriter = new ProtoWriter(stream, model, null)) { model.TrySerializeAuxiliaryType(protoWriter, null, format, tag, value, false); protoWriter.Close(); } commit = true; } finally { extensionObject.EndAppend(stream, commit); } }
internal static int Serialize(T instance, SerializationContext context) { // check for inheritance; if the instance is a subclass, then we // should serialize the sub-type first, allowing for more efficient // deserialization; note that we don't push the instance onto the // stack yet - we'll do that within each instance (otherwise deep // items could incorrectly count as cyclic). Type actualType = instance.GetType(); int total = 0, len; Callback(CallbackType.BeforeSerialization, instance); if (actualType != typeof(T)) { bool subclassFound = false; foreach (KeyValuePair <Type, Property <T, T> > subclass in subclasses) { if (subclass.Key.IsAssignableFrom(actualType)) { total += subclass.Value.Serialize(instance, context); subclassFound = true; break; } } if (!subclassFound) { throw new ProtoException("Unexpected type found during serialization; types must be included with ProtoIncludeAttribute; " + "found " + actualType.Name + " passed as " + typeof(T).Name); } } context.Push(instance); for (int i = 0; i < writeProps.Length; i++) { // note that this serialization includes the headers... total += writeProps[i].Serialize(instance, context); } IExtensible extensible = instance as IExtensible; IExtension extra = extensible == null ? null : extensible.GetExtensionObject(false); if (extra != null && (len = extra.GetLength()) > 0) { Stream extraStream = extra.BeginQuery(); try { context.WriteFrom(extraStream, len); total += len; } finally { extra.EndQuery(extraStream); } } context.Pop(instance); Callback(CallbackType.AfterSerialization, instance); return(total); }
#pragma warning disable RCS1163, IDE0060 // Unused parameter. /// <summary> /// All this does is call GetExtendedValuesTyped with the correct type for "instance"; /// this ensures that we don't get issues with subclasses declaring conflicting types - /// the caller must respect the fields defined for the type they pass in. /// </summary> internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag) #pragma warning restore RCS1163, IDE0060 // Unused parameter. { model ??= TypeModel.DefaultModel; if (instance == null) { ThrowHelper.ThrowArgumentNullException(nameof(instance)); } if (tag <= 0) { ThrowHelper.ThrowArgumentOutOfRangeException(nameof(tag)); } #pragma warning disable RCS1227 // Validate arguments correctly. IExtension extn = instance.GetExtensionObject(false); #pragma warning restore RCS1227 // Validate arguments correctly. if (extn == null) { yield break; } Stream stream = extn.BeginQuery(); try { object value = null; SerializationContext ctx = new SerializationContext(); var state = ProtoReader.State.Create(stream, model, ctx, ProtoReader.TO_EOF).Solidify(); try { while (model.TryDeserializeAuxiliaryType(ref state, format, tag, type, ref value, true, true, false, false, null) && value != null) { if (!singleton) { yield return(value); value = null; // fresh item each time } } if (singleton && value != null) { yield return(value); } } finally { state.Dispose(); } } finally { extn.EndQuery(stream); } }
internal static void AppendExtendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value) { model ??= TypeModel.DefaultModel; if (instance == null) { ThrowHelper.ThrowArgumentNullException(nameof(instance)); } if (value == null) { ThrowHelper.ThrowArgumentNullException(nameof(value)); } // TODO //model.CheckTagNotInUse(tag); // obtain the extension object and prepare to write IExtension extn = instance.GetExtensionObject(true); if (extn == null) { ThrowHelper.ThrowInvalidOperationException("No extension object available; appended data would be lost."); } bool commit = false; Stream stream = extn.BeginAppend(); try { var state = ProtoWriter.State.Create(stream, model, null); try { model.TrySerializeAuxiliaryType(ref state, null, format, tag, value, false, null); state.Close(); } catch { state.Abandon(); throw; } finally { state.Dispose(); } #pragma warning disable IDE0059 // Unnecessary assignment of a value - the rule is wrong; this matters commit = true; #pragma warning restore IDE0059 } finally { extn.EndAppend(stream, commit); } }
internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag) { if (instance == null) { throw new ArgumentNullException("instance"); } if (tag <= 0) { throw new ArgumentOutOfRangeException("tag"); } IExtension extensionObject = instance.GetExtensionObject(false); if (extensionObject != null) { Stream stream = extensionObject.BeginQuery(); object obj = null; ProtoReader protoReader = null; try { SerializationContext serializationContext = new SerializationContext(); protoReader = ProtoReader.Create(stream, model, serializationContext, -1); while (model.TryDeserializeAuxiliaryType(protoReader, format, tag, type, ref obj, true, false, false, false) && obj != null) { if (singleton) { continue; } yield return(obj); obj = null; } if (!singleton || obj == null) { goto Label0; } yield return(obj); } finally { ProtoReader.Recycle(protoReader); extensionObject.EndQuery(stream); } } Label0: yield break; }
/// <summary> /// All this does is call GetExtendedValuesTyped with the correct type for "instance"; /// this ensures that we don't get issues with subclasses declaring conflicting types - /// the caller must respect the fields defined for the type they pass in. /// </summary> internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag) { if (instance == null) { throw new ArgumentNullException(nameof(instance)); } if (tag <= 0) { throw new ArgumentOutOfRangeException(nameof(tag)); } IExtension extn = instance.GetExtensionObject(false); if (extn == null) { yield break; } Stream stream = extn.BeginQuery(); object value = null; ProtoReader reader = null; try { SerializationContext ctx = new SerializationContext(); reader = ProtoReader.Create(stream, model, ctx, ProtoReader.TO_EOF); while (model.TryDeserializeAuxiliaryType(reader, format, tag, type, ref value, true, false, false, false, null) && value != null) { if (!singleton) { yield return(value); value = null; // fresh item each time } } if (singleton && value != null) { yield return(value); } } finally { ProtoReader.Recycle(reader); extn.EndQuery(stream); } }
public static byte[] ToBytes(this IExtensible msg, int msgid) { int length = sizeof(short) + 2 + msg.GetExtensionObject(true).GetLength(); var buffer = PooledByteBufferAllocator.Default.Buffer(length + sizeof(int)).WithOrder(ByteOrder.LittleEndian); buffer.WriteInt(length); buffer.WriteShort(msgid); MemoryStream stream = new MemoryStream(buffer.Array, buffer.WriterIndex + buffer.ArrayOffset, msg.GetExtensionObject(true).GetLength()); Serializer.NonGeneric.Serialize(stream, msg); stream.Flush(); buffer.SetWriterIndex(sizeof(int) + length); var ret = buffer.ReadBytes(buffer.ReadableBytes).ToArray(); buffer.Release(); return(ret); }
internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag) { if (instance == null) { throw new ArgumentNullException("instance"); } if (tag <= 0) { throw new ArgumentOutOfRangeException("tag"); } IExtension extn = instance.GetExtensionObject(createIfMissing: false); if (extn != null) { Stream stream = extn.BeginQuery(); object value = null; ProtoReader reader = null; try { SerializationContext context = new SerializationContext(); reader = ProtoReader.Create(stream, model, context, -1); while (model.TryDeserializeAuxiliaryType(reader, format, tag, type, ref value, skipOtherFields: true, asListItem: false, autoCreate: false, insideList: false) && value != null) { if (!singleton) { yield return(value); value = null; } } if (singleton && value != null) { yield return(value); } } finally { ProtoReader.Recycle(reader); extn.EndQuery(stream); } } }
internal static void AppendExtendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value) { model ??= TypeModel.DefaultModel; if (instance is null) ThrowHelper.ThrowArgumentNullException(nameof(instance)); if (value is null) ThrowHelper.ThrowArgumentNullException(nameof(value)); // TODO //model.CheckTagNotInUse(tag); // obtain the extension object and prepare to write IExtension extn = instance.GetExtensionObject(true); if (extn is null) ThrowHelper.ThrowInvalidOperationException("No extension object available; appended data would be lost."); bool commit = false; Stream stream = extn.BeginAppend(); try { var state = ProtoWriter.State.Create(stream, model, null); try { model.TrySerializeAuxiliaryType(ref state, null, format, tag, value, false, null, isRoot: false); state.Close(); } catch { state.Abandon(); throw; } finally { state.Dispose(); } commit = true; } finally { extn.EndAppend(stream, commit); } }
static byte[] GetExtensionBytes(IExtensible obj) { Assert.IsNotNull(obj, "null extensible"); IExtension extn = obj.GetExtensionObject(false); Assert.IsNotNull(extn, "no extension object"); Stream s = extn.BeginQuery(); try { using (MemoryStream ms = new MemoryStream()) { int b; // really lazy clone... while ((b = s.ReadByte()) >= 0) { ms.WriteByte((byte)b); } return(ms.ToArray()); } } finally { extn.EndQuery(s); } }
/// <summary> /// Copies the current field into the instance as extension data /// </summary> public void AppendExtensionData(IExtensible instance) { if (instance == null) { throw new ArgumentNullException("instance"); } IExtension extn = instance.GetExtensionObject(true); bool commit = false; // unusually we *don't* want "using" here; the "finally" does that, with // the extension object being responsible for disposal etc Stream dest = extn.BeginAppend(); try { //TODO: replace this with stream-based, buffered raw copying using (ProtoWriter writer = new ProtoWriter(dest, model)) { AppendExtensionField(writer); writer.Close(); } commit = true; } finally { extn.EndAppend(dest, commit); } }
public void AppendExtensionData(IExtensible instance) { if (instance == null) { throw new ArgumentNullException("instance"); } IExtension extensionObject = instance.GetExtensionObject(true); bool commit = false; Stream stream = extensionObject.BeginAppend(); try { using (ProtoWriter protoWriter = new ProtoWriter(stream, this.model, null)) { this.AppendExtensionField(protoWriter); protoWriter.Close(); } commit = true; } finally { extensionObject.EndAppend(stream, commit); } }
/// <summary> /// Copies any extension data stored for the instance to the underlying stream /// </summary> public static void AppendExtensionData(IExtensible instance, ProtoWriter writer, ref State state) { if (instance == null) { throw new ArgumentNullException(nameof(instance)); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } // we expect the writer to be raw here; the extension data will have the // header detail, so we'll copy it implicitly if (writer.WireType != WireType.None) { throw CreateException(writer); } IExtension extn = instance.GetExtensionObject(false); if (extn != null) { // unusually we *don't* want "using" here; the "finally" does that, with // the extension object being responsible for disposal etc Stream source = extn.BeginQuery(); try { if (ProtoReader.TryConsumeSegmentRespectingPosition(source, out var data, ProtoReader.TO_EOF)) { writer.ImplWriteBytes(ref state, data.Array, data.Offset, data.Count); writer.Advance(data.Count); } else { writer.ImplCopyRawFromStream(ref state, source); } }
/// <summary> /// Copies the current field into the instance as extension data /// </summary> public void AppendExtensionData(IExtensible instance) { if (instance == null) throw new ArgumentNullException("instance"); IExtension extn = instance.GetExtensionObject(true); bool commit = false; // unusually we *don't* want "using" here; the "finally" does that, with // the extension object being responsible for disposal etc Stream dest = extn.BeginAppend(); try { //TODO: replace this with stream-based, buffered raw copying using (ProtoWriter writer = new ProtoWriter(dest, model)) { AppendExtensionField(writer); writer.Close(); } commit = true; } finally { extn.EndAppend(dest, commit); } }
internal static void Deserialize <TCreation>(ref T instance, SerializationContext context) where TCreation : class, T { uint prefix = 0; if (context == null) { throw new ArgumentNullException("context"); } #if !CF try { #endif if (instance != null) { Callback(CallbackType.BeforeDeserialization, instance); } context.Push(); int propCount = readProps.Length; //context.CheckSpace(); IExtensible extensible = instance as IExtensible; IExtension extn = null; Property <T> prop = propCount == 0 ? null : readProps[0]; int lastIndex = prop == null ? -1 : 0; uint lastPrefix = prop == null ? uint.MaxValue : prop.FieldPrefix; while (context.TryReadFieldPrefix(out prefix)) { // scan for the correct property bool foundTag = false; if (prefix == lastPrefix) { foundTag = true; } else if (prefix > lastPrefix) { for (int i = lastIndex + 1; i < propCount; i++) { if (readProps[i].FieldPrefix == prefix) { prop = readProps[i]; lastIndex = i; lastPrefix = prefix; foundTag = true; break; } if (readProps[i].FieldPrefix > prefix) { break; // too far } } } else { for (int i = lastIndex - 1; i >= 0; i--) { if (readProps[i].FieldPrefix == prefix) { prop = readProps[i]; lastIndex = i; lastPrefix = prefix; foundTag = true; break; } if (readProps[i].FieldPrefix < prefix) { break; // too far } } } if (!foundTag) { // check for subclass creation foreach (KeyValuePair <Type, Property <T, T> > subclass in subclasses) { // deserialize the nested data if (prefix == subclass.Value.FieldPrefix) { foundTag = true; instance = subclass.Value.DeserializeImpl(instance, context); break; } } if (foundTag) { continue; // nothing more to do for this... } } // not a sub-class, but *some* data there, so create an object if (instance == null) { instance = ObjectFactory <TCreation> .Create(); Callback(CallbackType.ObjectCreation, instance); extensible = instance as IExtensible; } if (foundTag) { // found it by seeking; deserialize and continue // ReSharper disable PossibleNullReferenceException try { prop.Deserialize(instance, context); } catch (UnexpectedDataException ex) { if (extensible != null) { if (extn == null) { extn = extensible.GetExtensionObject(true); } ex.Serialize(extn); } // DON'T re-throw; we've handled this } // ReSharper restore PossibleNullReferenceException continue; } WireType wireType; int fieldTag; Serializer.ParseFieldToken(prefix, out wireType, out fieldTag); if (wireType == WireType.EndGroup) { context.EndGroup(fieldTag); break; // this ends the entity, so stop the loop } // so we couldn't find it... if (extensible != null) { if (extn == null) { extn = extensible.GetExtensionObject(true); } Stream extraStream = extn.BeginAppend(); try { SerializationContext extraData = new SerializationContext(extraStream, null); // copy the data into the output stream // ReSharper disable PossibleNullReferenceException extraData.EncodeUInt32(prefix); // ReSharper restore PossibleNullReferenceException ProcessExtraData(context, fieldTag, wireType, extraData); extraData.Flush(); extn.EndAppend(extraStream, true); } catch { extn.EndAppend(extraStream, false); throw; } } else { // unexpected fields for an inextensible object; discard the data Serializer.SkipData(context, fieldTag, wireType); } } // final chance to create an instance - this only gets invoked for empty // messages (otherwise instance should already be non-null) if (instance == null) { instance = ObjectFactory <T> .Create(); Callback(CallbackType.ObjectCreation, instance); } context.Pop(); Callback(CallbackType.AfterDeserialization, instance); #if !CF } catch (Exception ex) { const string ErrorDataKey = "protoSource"; if (!ex.Data.Contains(ErrorDataKey)) { ex.Data.Add(ErrorDataKey, string.Format("tag={0}; wire-type={1}; offset={2}; depth={3}; type={4}", (int)(prefix >> 3), (WireType)(prefix & 7), context.Position, context.Depth, typeof(T).FullName)); } throw; } #endif }
/// <summary> /// All this does is call GetExtendedValuesTyped with the correct type for "instance"; /// this ensures that we don't get issues with subclasses declaring conflicting types - /// the caller must respect the fields defined for the type they pass in. /// </summary> internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag) { #if FEAT_IKVM throw new NotSupportedException(); #else if (instance == null) { throw new ArgumentNullException("instance"); } if (tag <= 0) { throw new ArgumentOutOfRangeException("tag"); } IExtension extn = instance.GetExtensionObject(false); if (extn == null) { #if FX11 return(new object[0]); #else yield break; #endif } #if FX11 BasicList result = new BasicList(); #endif Stream stream = extn.BeginQuery(); object value = null; ProtoReader reader = null; try { SerializationContext ctx = new SerializationContext(); reader = ProtoReader.Create(stream, model, ctx, ProtoReader.TO_EOF); while (model.TryDeserializeAuxiliaryType(reader, format, tag, type, ref value, true, false, false, false) && value != null) { if (!singleton) { #if FX11 result.Add(value); #else yield return(value); #endif value = null; // fresh item each time } } if (singleton && value != null) { #if FX11 result.Add(value); #else yield return(value); #endif } #if FX11 object[] resultArr = new object[result.Count]; result.CopyTo(resultArr, 0); return(resultArr); #endif } finally { ProtoReader.Recycle(reader); extn.EndQuery(stream); } #endif }
/// <summary> /// Copies any extension data stored for the instance to the underlying stream /// </summary> public static void AppendExtensionData(IExtensible instance, ProtoWriter writer) { if (instance == null) throw new ArgumentNullException("instance"); // we expect the writer to be raw here; the extension data will have the // header detail, so we'll copy it implicitly if(writer.wireType != WireType.None) throw CreateException(writer); IExtension extn = instance.GetExtensionObject(false); if (extn != null) { // unusually we *don't* want "using" here; the "finally" does that, with // the extension object being responsible for disposal etc Stream source = extn.BeginQuery(); try { CopyRawFromStream(source, writer); } finally { extn.EndQuery(source); } } }
public static void AppendExtensionData(IExtensible instance, ProtoWriter writer) { if (instance == null) { throw new ArgumentNullException("instance"); } if (writer == null) { throw new ArgumentNullException("writer"); } if (writer.wireType != WireType.None) { throw ProtoWriter.CreateException(writer); } IExtension extensionObject = instance.GetExtensionObject(false); if (extensionObject != null) { Stream stream = extensionObject.BeginQuery(); try { ProtoWriter.CopyRawFromStream(stream, writer); } finally { extensionObject.EndQuery(stream); } } }