public static StartSubItem ( object instance, |
||
instance | object | The instance to write. |
writer | The destination. | |
return | ProtoBuf.SubItemToken |
/// <summary> /// Writes a Guid to a protobuf stream /// </summary> public static void WriteGuid(Guid value, ProtoWriter dest) { byte[] blob = value.ToByteArray(); SubItemToken token = ProtoWriter.StartSubItem(null, dest); if (value != Guid.Empty) { ProtoWriter.WriteFieldHeader(FieldGuidLow, WireType.Fixed64, dest); ProtoWriter.WriteBytes(blob, 0, 8, dest); ProtoWriter.WriteFieldHeader(FieldGuidHigh, WireType.Fixed64, dest); ProtoWriter.WriteBytes(blob, 8, 8, dest); } ProtoWriter.EndSubItem(token, dest); }
private static void WriteSecondsNanos(long seconds, int nanos, ProtoWriter dest, ref ProtoWriter.State state) { SubItemToken token = ProtoWriter.StartSubItem(null, dest, ref state); if (seconds != 0) { ProtoWriter.WriteFieldHeader(1, WireType.Variant, dest, ref state); ProtoWriter.WriteInt64(seconds, dest, ref state); } if (nanos != 0) { ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest, ref state); ProtoWriter.WriteInt32(nanos, dest, ref state); } ProtoWriter.EndSubItem(token, dest, ref state); }
/// <summary> /// Writes an *implementation specific* bundled .NET object, including (as options) type-metadata, identity/re-use, etc. /// </summary> public static void WriteNetObject(object value, ProtoWriter dest, int key, bool dynamicType, bool asReference) { Helpers.DebugAssert(value != null); WireType wireType = dest.WireType; SubItemToken token = ProtoWriter.StartSubItem(null, dest); bool writeObject = true; if (asReference) { bool existing; int objectKey = dest.NetCache.AddObjectKey(value, out existing); ProtoWriter.WriteFieldHeader(existing ? FieldExistingObjectKey : FieldNewObjectKey, WireType.Variant, dest); ProtoWriter.WriteInt32(objectKey, dest); if (existing) { writeObject = false; } } if (writeObject) { if (dynamicType) { bool existing; Type type = value.GetType(); key = dest.GetTypeKey(ref type); int typeKey = dest.NetCache.AddObjectKey(type, out existing); ProtoWriter.WriteFieldHeader(existing ? FieldExistingTypeKey : FieldNewTypeKey, WireType.Variant, dest); ProtoWriter.WriteInt32(typeKey, dest); if (!existing) { ProtoWriter.WriteFieldHeader(FieldTypeName, WireType.String, dest); ProtoWriter.WriteString(dest.SerializeType(type), dest); } } ProtoWriter.WriteFieldHeader(FieldObject, wireType, dest); if (value is string) { ProtoWriter.WriteString((string)value, dest); } else { ProtoWriter.WriteObject(value, key, dest); } } ProtoWriter.EndSubItem(token, dest); }
internal static void WriteObject(ProtoWriter writer, ref State state, object value, int key, PrefixStyle style, int fieldNumber) { if (writer.model == null) { throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided"); } if (writer.WireType != WireType.None) { throw ProtoWriter.CreateException(writer); } switch (style) { case PrefixStyle.Base128: writer.WireType = WireType.String; writer.fieldNumber = fieldNumber; if (fieldNumber > 0) { WriteHeaderCore(fieldNumber, WireType.String, writer, ref state); } break; case PrefixStyle.Fixed32: case PrefixStyle.Fixed32BigEndian: writer.fieldNumber = 0; writer.WireType = WireType.Fixed32; break; default: throw new ArgumentOutOfRangeException(nameof(style)); } SubItemToken token = writer.StartSubItem(ref state, value, style); if (key < 0) { if (!writer.model.TrySerializeAuxiliaryType(writer, ref state, value.GetType(), DataFormat.Default, TypeModel.ListItemTag, value, false, null)) { TypeModel.ThrowUnexpectedType(value.GetType()); } } else { writer.model.Serialize(writer, ref state, key, value); } writer.EndSubItem(ref state, token, style); }
// Token: 0x06000139 RID: 313 RVA: 0x0000CF44 File Offset: 0x0000B144 internal static void WriteObject(object value, int key, ProtoWriter writer, PrefixStyle style, int fieldNumber) { if (writer.model == null) { throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided"); } if (writer.wireType != WireType.None) { throw ProtoWriter.CreateException(writer); } if (style != PrefixStyle.Base128) { if (style - PrefixStyle.Fixed32 > 1) { throw new ArgumentOutOfRangeException("style"); } writer.fieldNumber = 0; writer.wireType = WireType.Fixed32; } else { writer.wireType = WireType.String; writer.fieldNumber = fieldNumber; if (fieldNumber > 0) { ProtoWriter.WriteHeaderCore(fieldNumber, WireType.String, writer); } } SubItemToken token = ProtoWriter.StartSubItem(value, writer, true); if (key < 0) { if (!writer.model.TrySerializeAuxiliaryType(writer, value.GetType(), DataFormat.Default, 1, value, false)) { TypeModel.ThrowUnexpectedType(value.GetType()); } } else { writer.model.Serialize(key, value, writer); } ProtoWriter.EndSubItem(token, writer, style); }
/// <summary> /// Writes a decimal to a protobuf stream /// </summary> public static void WriteDecimal(decimal value, ProtoWriter writer) { int[] bits = decimal.GetBits(value); ulong a = ((ulong)bits[1]) << 32, b = ((ulong)bits[0]) & 0xFFFFFFFFL; ulong low = a | b; uint high = (uint)bits[2]; uint signScale = (uint)(((bits[3] >> 15) & 0x01FE) | ((bits[3] >> 31) & 0x0001)); SubItemToken token = ProtoWriter.StartSubItem(null, writer); if (low != 0) { ProtoWriter.WriteFieldHeader(FieldDecimalLow, WireType.Variant, writer); ProtoWriter.WriteUInt64(low, writer); } if (high != 0) { ProtoWriter.WriteFieldHeader(FieldDecimalHigh, WireType.Variant, writer); ProtoWriter.WriteUInt32(high, writer); } if (signScale != 0) { ProtoWriter.WriteFieldHeader(FieldDecimalSignScale, WireType.Variant, writer); ProtoWriter.WriteUInt32(signScale, writer); } ProtoWriter.EndSubItem(token, writer); }
public static void WriteObject(object value, int key, ProtoWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } if (writer.model == null) { throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided"); } SubItemToken subItemToken = ProtoWriter.StartSubItem(value, writer); if (key >= 0) { writer.model.Serialize(key, value, writer); } else if (writer.model == null || !writer.model.TrySerializeAuxiliaryType(writer, value.GetType(), DataFormat.Default, 1, value, false)) { TypeModel.ThrowUnexpectedType(value.GetType()); } ProtoWriter.EndSubItem(subItemToken, writer); }
private void AppendExtensionField(ProtoWriter writer) { //TODO: replace this with stream-based, buffered raw copying ProtoWriter.WriteFieldHeader(fieldNumber, wireType, writer); switch (wireType) { case WireType.Fixed32: ProtoWriter.WriteInt32(ReadInt32(), writer); return; case WireType.Variant: case WireType.SignedVariant: case WireType.Fixed64: ProtoWriter.WriteInt64(ReadInt64(), writer); return; case WireType.String: ProtoWriter.WriteBytes(AppendBytes(null, this), writer); return; case WireType.StartGroup: SubItemToken readerToken = StartSubItem(this), writerToken = ProtoWriter.StartSubItem(null, writer); while (ReadFieldHeader() > 0) { AppendExtensionField(writer); } EndSubItem(readerToken, this); ProtoWriter.EndSubItem(writerToken, writer); return; case WireType.None: // treat as explicit errorr case WireType.EndGroup: // treat as explicit error default: // treat as implicit error throw CreateException(); } }
private void AppendExtensionField(ProtoWriter writer) { ProtoWriter.WriteFieldHeader(this.fieldNumber, this.wireType, writer); WireType wireType = this.wireType; switch (wireType + 1) { case WireType.Fixed64: case WireType.String: case (WireType)9: ProtoWriter.WriteInt64(this.ReadInt64(), writer); return; case WireType.StartGroup: ProtoWriter.WriteBytes(ProtoReader.AppendBytes(null, this), writer); return; case WireType.EndGroup: { SubItemToken token = ProtoReader.StartSubItem(this); SubItemToken token2 = ProtoWriter.StartSubItem(null, writer); while (this.ReadFieldHeader() > 0) { this.AppendExtensionField(writer); } ProtoReader.EndSubItem(token, this); ProtoWriter.EndSubItem(token2, writer); return; } case (WireType)6: ProtoWriter.WriteInt32(this.ReadInt32(), writer); return; } throw this.CreateWireTypeException(); }
private void AppendExtensionField(ProtoWriter writer) { ProtoWriter.WriteFieldHeader(fieldNumber, wireType, writer); switch (wireType) { case WireType.Fixed32: ProtoWriter.WriteInt32(ReadInt32(), writer); break; case WireType.Variant: case WireType.Fixed64: case WireType.SignedVariant: ProtoWriter.WriteInt64(ReadInt64(), writer); break; case WireType.String: ProtoWriter.WriteBytes(AppendBytes(null, this), writer); break; case WireType.StartGroup: { SubItemToken token = StartSubItem(this); SubItemToken token2 = ProtoWriter.StartSubItem(null, writer); while (ReadFieldHeader() > 0) { AppendExtensionField(writer); } EndSubItem(token, this); ProtoWriter.EndSubItem(token2, writer); break; } default: throw CreateWireTypeException(); } }
/// <summary> /// Indicates the start of a nested record. /// </summary> /// <param name="instance">The instance to write.</param> /// <param name="writer">The destination.</param> /// <param name="state">Writer state</param> /// <returns>A token representing the state of the stream; this token is given to EndSubItem.</returns> public static SubItemToken StartSubItem(object instance, ProtoWriter writer, ref State state) => writer.StartSubItem(ref state, instance, PrefixStyle.Base128);
public static SubItemToken StartSubItem(object instance, ProtoWriter writer) { State state = writer.DefaultState(); return(writer.StartSubItem(ref state, instance, PrefixStyle.Base128)); }
private static void WriteTimeSpanImpl(TimeSpan timeSpan, ProtoWriter dest, DateTimeKind kind) { if (dest == null) { throw new ArgumentNullException("dest"); } long value; switch (dest.WireType) { case WireType.String: case WireType.StartGroup: TimeSpanScale scale; value = timeSpan.Ticks; if (timeSpan == TimeSpan.MaxValue) { value = 1; scale = TimeSpanScale.MinMax; } else if (timeSpan == TimeSpan.MinValue) { value = -1; scale = TimeSpanScale.MinMax; } else if (value % TimeSpan.TicksPerDay == 0) { scale = TimeSpanScale.Days; value /= TimeSpan.TicksPerDay; } else if (value % TimeSpan.TicksPerHour == 0) { scale = TimeSpanScale.Hours; value /= TimeSpan.TicksPerHour; } else if (value % TimeSpan.TicksPerMinute == 0) { scale = TimeSpanScale.Minutes; value /= TimeSpan.TicksPerMinute; } else if (value % TimeSpan.TicksPerSecond == 0) { scale = TimeSpanScale.Seconds; value /= TimeSpan.TicksPerSecond; } else if (value % TimeSpan.TicksPerMillisecond == 0) { scale = TimeSpanScale.Milliseconds; value /= TimeSpan.TicksPerMillisecond; } else { scale = TimeSpanScale.Ticks; } SubItemToken token = ProtoWriter.StartSubItem(null, dest); if (value != 0) { ProtoWriter.WriteFieldHeader(FieldTimeSpanValue, WireType.SignedVariant, dest); ProtoWriter.WriteInt64(value, dest); } if (scale != TimeSpanScale.Days) { ProtoWriter.WriteFieldHeader(FieldTimeSpanScale, WireType.Variant, dest); ProtoWriter.WriteInt32((int)scale, dest); } if (kind != DateTimeKind.Unspecified) { ProtoWriter.WriteFieldHeader(FieldTimeSpanKind, WireType.Variant, dest); ProtoWriter.WriteInt32((int)kind, dest); } ProtoWriter.EndSubItem(token, dest); break; case WireType.Fixed64: ProtoWriter.WriteInt64(timeSpan.Ticks, dest); break; default: throw new ProtoException("Unexpected wire-type: " + dest.WireType.ToString()); } }
/// <summary> /// Writes an *implementation specific* bundled .NET object, including (as options) type-metadata, identity/re-use, etc. /// </summary> public static void WriteNetObject(object value, ProtoWriter dest, int key, NetObjectOptions options) { #if FEAT_IKVM throw new NotSupportedException(); #else if (dest == null) { throw new ArgumentNullException("dest"); } bool dynamicType = (options & NetObjectOptions.DynamicType) != 0, asReference = (options & NetObjectOptions.AsReference) != 0; WireType wireType = dest.WireType; SubItemToken token = ProtoWriter.StartSubItem(null, dest); bool writeObject = true; if (asReference) { bool existing; int objectKey = dest.NetCache.AddObjectKey(value, out existing); ProtoWriter.WriteFieldHeader(existing ? FieldExistingObjectKey : FieldNewObjectKey, WireType.Variant, dest); ProtoWriter.WriteInt32(objectKey, dest); if (existing) { writeObject = false; } } if (writeObject) { if (dynamicType) { bool existing; Type type = value.GetType(); if (!(value is string)) { key = dest.GetTypeKey(ref type); if (key < 0) { throw new InvalidOperationException("Dynamic type is not a contract-type: " + type.Name); } } int typeKey = dest.NetCache.AddObjectKey(type, out existing); ProtoWriter.WriteFieldHeader(existing ? FieldExistingTypeKey : FieldNewTypeKey, WireType.Variant, dest); ProtoWriter.WriteInt32(typeKey, dest); if (!existing) { ProtoWriter.WriteFieldHeader(FieldTypeName, WireType.String, dest); ProtoWriter.WriteString(dest.SerializeType(type), dest); } } ProtoWriter.WriteFieldHeader(FieldObject, wireType, dest); if (value is string) { ProtoWriter.WriteString((string)value, dest); } else { ProtoWriter.WriteObject(value, key, dest); } } ProtoWriter.EndSubItem(token, dest); #endif }
public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest) { if (dest == null) { throw new ArgumentNullException("dest"); } switch (dest.WireType) { case WireType.String: case WireType.StartGroup: { long num = timeSpan.Ticks; TimeSpanScale timeSpanScale; if (timeSpan == TimeSpan.MaxValue) { num = 1L; timeSpanScale = TimeSpanScale.MinMax; } else if (timeSpan == TimeSpan.MinValue) { num = -1L; timeSpanScale = TimeSpanScale.MinMax; } else if (num % 864000000000L == 0L) { timeSpanScale = TimeSpanScale.Days; num /= 864000000000L; } else if (num % 36000000000L == 0L) { timeSpanScale = TimeSpanScale.Hours; num /= 36000000000L; } else if (num % 600000000 == 0L) { timeSpanScale = TimeSpanScale.Minutes; num /= 600000000; } else if (num % 10000000 == 0L) { timeSpanScale = TimeSpanScale.Seconds; num /= 10000000; } else if (num % 10000 == 0L) { timeSpanScale = TimeSpanScale.Milliseconds; num /= 10000; } else { timeSpanScale = TimeSpanScale.Ticks; } SubItemToken token = ProtoWriter.StartSubItem(null, dest); if (num != 0L) { ProtoWriter.WriteFieldHeader(1, WireType.SignedVariant, dest); ProtoWriter.WriteInt64(num, dest); } if (timeSpanScale != 0) { ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest); ProtoWriter.WriteInt32((int)timeSpanScale, dest); } ProtoWriter.EndSubItem(token, dest); break; } case WireType.Fixed64: ProtoWriter.WriteInt64(timeSpan.Ticks, dest); break; default: throw new ProtoException("Unexpected wire-type: " + dest.WireType); } }
public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest) { if (dest == null) { throw new ArgumentNullException("dest"); } WireType wireType = dest.WireType; if (wireType != WireType.Fixed64) { if ((uint)(wireType - 2) <= 1u) { long num = timeSpan.Ticks; TimeSpanScale timeSpanScale; if (timeSpan == TimeSpan.MaxValue) { num = 1L; timeSpanScale = TimeSpanScale.MinMax; } else if (timeSpan == TimeSpan.MinValue) { num = -1L; timeSpanScale = TimeSpanScale.MinMax; } else if (num % 864000000000L == 0L) { timeSpanScale = TimeSpanScale.Days; num /= 864000000000L; } else if (num % 36000000000L == 0L) { timeSpanScale = TimeSpanScale.Hours; num /= 36000000000L; } else if (num % 600000000 == 0L) { timeSpanScale = TimeSpanScale.Minutes; num /= 600000000; } else if (num % 10000000 == 0L) { timeSpanScale = TimeSpanScale.Seconds; num /= 10000000; } else if (num % 10000 == 0L) { timeSpanScale = TimeSpanScale.Milliseconds; num /= 10000; } else { timeSpanScale = TimeSpanScale.Ticks; } SubItemToken token = ProtoWriter.StartSubItem(null, dest); if (num != 0L) { ProtoWriter.WriteFieldHeader(1, WireType.SignedVariant, dest); ProtoWriter.WriteInt64(num, dest); } if (timeSpanScale != 0) { ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest); ProtoWriter.WriteInt32((int)timeSpanScale, dest); } ProtoWriter.EndSubItem(token, dest); return; } wireType = dest.WireType; throw new ProtoException("Unexpected wire-type: " + wireType.ToString()); } ProtoWriter.WriteInt64(timeSpan.Ticks, dest); }
public static SubItemToken StartSubItem(object instance, ProtoWriter writer) { return(ProtoWriter.StartSubItem(instance, writer, false)); }
public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest) { TimeSpanScale timeSpanScale; if (dest == null) { throw new ArgumentNullException("dest"); } switch (dest.WireType) { case WireType.Fixed64: { ProtoWriter.WriteInt64(timeSpan.Ticks, dest); return; } case WireType.String: case WireType.StartGroup: { long ticks = timeSpan.Ticks; if (timeSpan == TimeSpan.MaxValue) { ticks = (long)1; timeSpanScale = TimeSpanScale.MinMax; } else if (timeSpan == TimeSpan.MinValue) { ticks = (long)-1; timeSpanScale = TimeSpanScale.MinMax; } else if (ticks % 864000000000L == (long)0) { timeSpanScale = TimeSpanScale.Days; ticks /= 864000000000L; } else if (ticks % 36000000000L == (long)0) { timeSpanScale = TimeSpanScale.Hours; ticks /= 36000000000L; } else if (ticks % (long)600000000 == (long)0) { timeSpanScale = TimeSpanScale.Minutes; ticks /= (long)600000000; } else if (ticks % (long)10000000 == (long)0) { timeSpanScale = TimeSpanScale.Seconds; ticks /= (long)10000000; } else if (ticks % (long)10000 != (long)0) { timeSpanScale = TimeSpanScale.Ticks; } else { timeSpanScale = TimeSpanScale.Milliseconds; ticks /= (long)10000; } SubItemToken subItemToken = ProtoWriter.StartSubItem(null, dest); if (ticks != (long)0) { ProtoWriter.WriteFieldHeader(1, WireType.SignedVariant, dest); ProtoWriter.WriteInt64(ticks, dest); } if (timeSpanScale != TimeSpanScale.Days) { ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest); ProtoWriter.WriteInt32((int)timeSpanScale, dest); } ProtoWriter.EndSubItem(subItemToken, dest); return; } } throw new ProtoException(string.Concat("Unexpected wire-type: ", dest.WireType.ToString())); }