static public int constructor(IntPtr l)
 {
     try {
         ProtoBuf.SubItemToken o;
         o = new ProtoBuf.SubItemToken();
         pushValue(l, true);
         pushValue(l, o);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Пример #2
0
        // 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);
        }
Пример #3
0
        internal static object ReadTypedObject(object value, int key, ProtoReader reader, Type type)
        {
            if (reader.model == null)
            {
                throw AddErrorData(new InvalidOperationException("Cannot deserialize sub-objects unless a model is provided"), reader);
            }
            SubItemToken token = StartSubItem(reader);

            if (key >= 0)
            {
                value = reader.model.Deserialize(key, value, reader);
            }
            else if (!(type != (Type)null) || !reader.model.TryDeserializeAuxiliaryType(reader, DataFormat.Default, 1, type, ref value, true, false, true, false))
            {
                TypeModel.ThrowUnexpectedType(type);
            }
            EndSubItem(token, reader);
            return(value);
        }
Пример #4
0
        private static SubItemToken StartSubItem(object instance, ProtoWriter writer, bool allowFixed)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            if (++writer.depth > 25)
            {
                writer.CheckRecursionStackAndPush(instance);
            }
            if (writer.packedFieldNumber != 0)
            {
                throw new InvalidOperationException("Cannot begin a sub-item while performing packed encoding");
            }
            switch (writer.wireType)
            {
            case WireType.String:
                writer.wireType = WireType.None;
                ProtoWriter.DemandSpace(32, writer);
                writer.flushLock++;
                writer.position++;
                return(new SubItemToken(writer.ioIndex++));

            case WireType.StartGroup:
                writer.wireType = WireType.None;
                return(new SubItemToken(-writer.fieldNumber));

            case WireType.Fixed32:
            {
                if (!allowFixed)
                {
                    throw ProtoWriter.CreateException(writer);
                }
                ProtoWriter.DemandSpace(32, writer);
                writer.flushLock++;
                SubItemToken result = new SubItemToken(writer.ioIndex);
                ProtoWriter.IncrementedAndReset(4, writer);
                return(result);
            }
            }
            throw ProtoWriter.CreateException(writer);
        }
Пример #5
0
        public static decimal ReadDecimal(ProtoReader reader)
        {
            ulong        num   = 0uL;
            uint         num2  = 0u;
            uint         num3  = 0u;
            SubItemToken token = ProtoReader.StartSubItem(reader);
            int          num4;

            while ((num4 = reader.ReadFieldHeader()) > 0)
            {
                switch (num4)
                {
                case 1:
                    num = reader.ReadUInt64();
                    break;

                case 2:
                    num2 = reader.ReadUInt32();
                    break;

                case 3:
                    num3 = reader.ReadUInt32();
                    break;

                default:
                    reader.SkipField();
                    break;
                }
            }
            ProtoReader.EndSubItem(token, reader);
            if (num == 0uL && num2 == 0u)
            {
                return(0m);
            }
            int  num5 = (int)(num & (ulong)-1);
            int  num6 = (int)(num >> 32 & (ulong)-1);
            int  num7 = (int)num2;
            bool flag = (num3 & 1u) == 1u;
            byte b    = (byte)((num3 & 510u) >> 1);

            return(new decimal(num5, num6, num7, flag, b));
        }
Пример #6
0
        /// <summary>
        /// Parses a decimal from a protobuf stream
        /// </summary>
        public static decimal ReadDecimal(ProtoReader reader)
        {
            ulong low       = 0;
            uint  high      = 0;
            uint  signScale = 0;


            int          fieldNumber;
            SubItemToken token = ProtoReader.StartSubItem(reader);

            while ((fieldNumber = reader.ReadFieldHeader()) > 0)
            {
                switch (fieldNumber)
                {
                case FieldDecimalLow:
                    low = reader.ReadUInt64(); break;

                case FieldDecimalHigh:
                    high = reader.ReadUInt32(); break;

                case FieldDecimalSignScale:
                    signScale = reader.ReadUInt32(); break;

                default:
                    reader.SkipField(); break;
                }
            }
            ProtoReader.EndSubItem(token, reader);

            if (low == 0 && high == 0)
            {
                return(decimal.Zero);
            }

            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));
        }
Пример #7
0
        /// <summary>

        /// Write an encapsulated sub-object, using the supplied unique key (reprasenting a type).

        /// </summary>

        /// <param name="value">The object to write.</param>

        /// <param name="key">The key that uniquely identifies the type within the model.</param>

        /// <param name="writer">The destination.</param>

        public static void WriteObject(object value, int key, ProtoWriter writer)

        {
#if FEAT_IKVM
            throw new NotSupportedException();
#else
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }

            if (writer.model == null)

            {
                throw new InvalidOperationException("Cannot serialize sub-objects unless a model is provided");
            }



            SubItemToken token = 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, Serializer.ListItemTag, value, false))

            {
                // all ok
            }

            else

            {
                TypeModel.ThrowUnexpectedType(value.GetType());
            }

            EndSubItem(token, writer);
#endif
        }
Пример #8
0
        public static decimal ReadDecimal(ProtoReader reader)
        {
            ulong        num   = 0uL;
            uint         num2  = 0u;
            uint         num3  = 0u;
            SubItemToken token = ProtoReader.StartSubItem(reader);
            int          num4;

            while ((num4 = reader.ReadFieldHeader()) > 0)
            {
                switch (num4)
                {
                case 1:
                    num = reader.ReadUInt64();
                    break;

                case 2:
                    num2 = reader.ReadUInt32();
                    break;

                case 3:
                    num3 = reader.ReadUInt32();
                    break;

                default:
                    reader.SkipField();
                    break;
                }
            }
            ProtoReader.EndSubItem(token, reader);
            if (num == 0L && num2 == 0)
            {
                return(0m);
            }
            int  lo         = (int)(num & uint.MaxValue);
            int  mid        = (int)((num >> 32) & uint.MaxValue);
            int  hi         = (int)num2;
            bool isNegative = (num3 & 1) == 1;
            byte scale      = (byte)((num3 & 0x1FE) >> 1);

            return(new decimal(lo, mid, hi, isNegative, scale));
        }
Пример #9
0
        /// <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);
        }
Пример #10
0
        /// <summary>

        /// Write an encapsulated sub-object, using the supplied unique key (reprasenting a type) - but the

        /// caller is asserting that this relationship is non-recursive; no recursion check will be

        /// performed.

        /// </summary>

        /// <param name="value">The object to write.</param>

        /// <param name="key">The key that uniquely identifies the type within the model.</param>

        /// <param name="writer">The destination.</param>

        public static void WriteRecursionSafeObject(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 token = StartSubItem(null, writer);

            writer.model.Serialize(key, value, writer);

            EndSubItem(token, writer);
        }
Пример #11
0
        private static SubItemToken StartSubItem(object instance, ProtoWriter writer, bool allowFixed)
        {
            if (++writer.depth > RecursionCheckDepth)
            {
                writer.CheckRecursionStackAndPush(instance);
            }
            if (writer.packedFieldNumber != 0)
            {
                throw new InvalidOperationException("Cannot begin a sub-item while performing packed encoding");
            }
            switch (writer.wireType)
            {
            case WireType.StartGroup:
                writer.wireType = WireType.None;
                return(new SubItemToken(-writer.fieldNumber));

            case WireType.String:
                writer.wireType = WireType.None;
                DemandSpace(32, writer);     // make some space in anticipation...
                writer.flushLock++;
                writer.position++;
                return(new SubItemToken(writer.ioIndex++));    // leave 1 space (optimistic) for length

            case WireType.Fixed32:
            {
                if (!allowFixed)
                {
                    throw CreateException(writer);
                }
                DemandSpace(32, writer);         // make some space in anticipation...
                writer.flushLock++;
                SubItemToken token = new SubItemToken(writer.ioIndex);
                ProtoWriter.IncrementedAndReset(4, writer);         // leave 4 space (rigid) for length
                return(token);
            }

            default:
                throw CreateException(writer);
            }
        }
Пример #12
0
        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);
        }
Пример #13
0
            private protected override SubItemToken ImplStartLengthPrefixedSubItem(ref State state, object instance, PrefixStyle style)
            {
                switch (WireType)
                {
                case WireType.String:
                    WireType = WireType.None;
                    DemandSpace(32, this, ref state);     // make some space in anticipation...
                    flushLock++;
                    Advance(1);
                    return(new SubItemToken((long)(ioIndex++)));    // leave 1 space (optimistic) for length

                case WireType.Fixed32:
                    DemandSpace(32, this, ref state);     // make some space in anticipation...
                    flushLock++;
                    SubItemToken token = new SubItemToken((long)ioIndex);
                    IncrementedAndReset(4, this);     // leave 4 space (rigid) for length
                    return(token);

                default:
                    throw CreateException(this);
                }
            }
Пример #14
0
        /// <summary>

        /// Parses a Guid from a protobuf stream

        /// </summary>

        public static Guid ReadGuid(ProtoReader source)

        {
            ulong low = 0, high = 0;

            int fieldNumber;

            SubItemToken token = ProtoReader.StartSubItem(source);

            while ((fieldNumber = source.ReadFieldHeader()) > 0)

            {
                switch (fieldNumber)

                {
                case FieldGuidLow: low = source.ReadUInt64(); break;

                case FieldGuidHigh: high = source.ReadUInt64(); break;

                default: source.SkipField(); break;
                }
            }

            ProtoReader.EndSubItem(token, source);

            if (low == 0 && high == 0)
            {
                return(Guid.Empty);
            }

            uint a = (uint)(low >> 32), b = (uint)low, c = (uint)(high >> 32), d = (uint)high;

            return(new Guid((int)b, (short)a, (short)(a >> 16),

                            (byte)d, (byte)(d >> 8), (byte)(d >> 16), (byte)(d >> 24),

                            (byte)c, (byte)(c >> 8), (byte)(c >> 16), (byte)(c >> 24)));
        }
Пример #15
0
        public static Guid ReadGuid(ProtoReader source)
        {
            ulong        num   = 0uL;
            ulong        num2  = 0uL;
            SubItemToken token = ProtoReader.StartSubItem(source);
            int          num3;

            while ((num3 = source.ReadFieldHeader()) > 0)
            {
                int num4 = num3;
                if (num4 != 1)
                {
                    if (num4 != 2)
                    {
                        source.SkipField();
                    }
                    else
                    {
                        num2 = source.ReadUInt64();
                    }
                }
                else
                {
                    num = source.ReadUInt64();
                }
            }
            ProtoReader.EndSubItem(token, source);
            if (num == 0uL && num2 == 0uL)
            {
                return(Guid.Empty);
            }
            uint num5 = (uint)(num >> 32);
            uint num6 = (uint)num;
            uint num7 = (uint)(num2 >> 32);
            uint num8 = (uint)num2;

            return(new Guid((int)num6, (short)num5, (short)(num5 >> 16), (byte)num8, (byte)(num8 >> 8), (byte)(num8 >> 16), (byte)(num8 >> 24), (byte)num7, (byte)(num7 >> 8), (byte)(num7 >> 16), (byte)(num7 >> 24)));
        }
Пример #16
0
        /// <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);
        }
Пример #17
0
        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();
            }
        }
Пример #18
0
        /// <summary>
        /// Makes the end of consuming a nested message in the stream; the stream must be either at the correct EndGroup
        /// marker, or all fields of the sub-message must have been consumed (in either case, this means ReadFieldHeader
        /// should return zero)
        /// </summary>
        public static void EndSubItem(SubItemToken token, ProtoReader reader)
        {
            int value = token.value;

            switch (reader.wireType)
            {
            case WireType.EndGroup:
                if (value >= 0)
                {
                    throw AddErrorData(new ArgumentException("token"), reader);
                }
                if (-value != reader.fieldNumber)
                {
                    throw reader.CreateException();  // wrong group ended!
                }
                reader.wireType = WireType.None;     // this releases ReadFieldHeader
                reader.depth--;
                break;

            // case WireType.None: // TODO reinstate once reads reset the wire-type
            default:
                if (value < reader.position)
                {
                    throw reader.CreateException();
                }
                if (reader.blockEnd != reader.position && reader.blockEnd != int.MaxValue)
                {
                    throw reader.CreateException();
                }
                reader.blockEnd = value;
                reader.depth--;
                break;

                /*default:
                 *  throw reader.BorkedIt(); */
            }
        }
Пример #19
0
        public static void EndSubItem(SubItemToken token, ProtoReader reader)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            int      value    = token.value;
            WireType wireType = reader.wireType;

            if (wireType != WireType.EndGroup)
            {
                if (value < reader.position)
                {
                    throw reader.CreateException("Sub-message not read entirely");
                }
                if (reader.blockEnd != reader.position && reader.blockEnd != 2147483647)
                {
                    throw reader.CreateException("Sub-message not read correctly");
                }
                reader.blockEnd = value;
                reader.depth--;
            }
            else
            {
                if (value >= 0)
                {
                    throw ProtoReader.AddErrorData(new ArgumentException("token"), reader);
                }
                if (-value != reader.fieldNumber)
                {
                    throw reader.CreateException("Wrong group was ended");
                }
                reader.wireType = WireType.None;
                reader.depth--;
            }
        }
Пример #20
0
        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();
        }
Пример #21
0
        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);
            }

            switch (style)
            {
            case PrefixStyle.Base128:
                writer.wireType    = WireType.String;
                writer.fieldNumber = fieldNumber;
                if (fieldNumber > 0)
                {
                    WriteHeaderCore(fieldNumber, WireType.String, writer);
                }
                break;

            case PrefixStyle.Fixed32:
            case PrefixStyle.Fixed32BigEndian:
                writer.fieldNumber = 0;
                writer.wireType    = WireType.Fixed32;
                break;

            default:
                throw new ArgumentOutOfRangeException("style");
            }
            SubItemToken token = StartSubItem(value, writer, true);

            writer.model.Serialize(key, value, writer);
            EndSubItem(token, writer, style);
        }
Пример #22
0
        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();
            }
        }
Пример #23
0
        public static Guid ReadGuid(ProtoReader source)
        {
            ulong        num   = 0uL;
            ulong        num2  = 0uL;
            SubItemToken token = ProtoReader.StartSubItem(source);
            int          num3;

            while ((num3 = source.ReadFieldHeader()) > 0)
            {
                switch (num3)
                {
                case 1:
                    num = source.ReadUInt64();
                    break;

                case 2:
                    num2 = source.ReadUInt64();
                    break;

                default:
                    source.SkipField();
                    break;
                }
            }
            ProtoReader.EndSubItem(token, source);
            if (num == 0L && num2 == 0L)
            {
                return(Guid.Empty);
            }
            uint num4 = (uint)(num >> 32);
            int  a    = (int)num;
            uint num5 = (uint)(num2 >> 32);
            uint num6 = (uint)num2;

            return(new Guid(a, (short)num4, (short)(num4 >> 16), (byte)num6, (byte)(num6 >> 8), (byte)(num6 >> 16), (byte)(num6 >> 24), (byte)num5, (byte)(num5 >> 8), (byte)(num5 >> 16), (byte)(num5 >> 24)));
        }
Пример #24
0
 /// <summary>
 /// Indicates the end of a nested record.
 /// </summary>
 /// <param name="token">The token obtained from StartubItem.</param>
 /// <param name="writer">The destination.</param>
 /// <param name="state">Writer state</param>
 public static void EndSubItem(SubItemToken token, ProtoWriter writer, ref State state)
 => writer.EndSubItem(ref state, token, PrefixStyle.Base128);
Пример #25
0
        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());
            }
        }
Пример #26
0
        public static void EndSubItem(SubItemToken token, ProtoWriter writer)
        {
            State state = writer.DefaultState();

            writer.EndSubItem(ref state, token, PrefixStyle.Base128);
        }
Пример #27
0
        /// <summary>
        /// Reads an *implementation specific* bundled .NET object, including (as options) type-metadata, identity/re-use, etc.
        /// </summary>
        public static object ReadNetObject(object value, ProtoReader source, int key, Type type, NetObjectOptions options)
        {
#if FEAT_IKVM
            throw new NotSupportedException();
#else
            SubItemToken token = ProtoReader.StartSubItem(source);
            int          fieldNumber;
            int          newObjectKey = -1, newTypeKey = -1, tmp;
            while ((fieldNumber = source.ReadFieldHeader()) > 0)
            {
                switch (fieldNumber)
                {
                case FieldExistingObjectKey:
                    tmp   = source.ReadInt32();
                    value = source.NetCache.GetKeyedObject(tmp);
                    break;

                case FieldNewObjectKey:
                    newObjectKey = source.ReadInt32();
                    break;

                case FieldExistingTypeKey:
                    tmp  = source.ReadInt32();
                    type = (Type)source.NetCache.GetKeyedObject(tmp);
                    key  = source.GetTypeKey(ref type);
                    break;

                case FieldNewTypeKey:
                    newTypeKey = source.ReadInt32();
                    break;

                case FieldTypeName:
                    string typeName = source.ReadString();
                    type = source.DeserializeType(typeName);
                    if (type == null)
                    {
                        throw new ProtoException("Unable to resolve type: " + typeName + " (you can use the TypeModel.DynamicTypeFormatting event to provide a custom mapping)");
                    }
                    if (type == typeof(string))
                    {
                        key = -1;
                    }
                    else
                    {
                        key = source.GetTypeKey(ref type);
                        if (key < 0)
                        {
                            throw new InvalidOperationException("Dynamic type is not a contract-type: " + type.Name);
                        }
                    }
                    break;

                case FieldObject:
                    bool isString = type == typeof(string);
                    bool wasNull  = value == null;
                    bool lateSet  = wasNull && (isString || ((options & NetObjectOptions.LateSet) != 0));

                    if (newObjectKey >= 0 && !lateSet)
                    {
                        if (value == null)
                        {
                            source.TrapNextObject(newObjectKey);
                        }
                        else
                        {
                            source.NetCache.SetKeyedObject(newObjectKey, value);
                        }
                        if (newTypeKey >= 0)
                        {
                            source.NetCache.SetKeyedObject(newTypeKey, type);
                        }
                    }
                    object oldValue = value;
                    if (isString)
                    {
                        value = source.ReadString();
                    }
                    else
                    {
                        value = ProtoReader.ReadTypedObject(oldValue, key, source, type);
                    }

                    if (newObjectKey >= 0)
                    {
                        if (wasNull && !lateSet)
                        {     // this both ensures (via exception) that it *was* set, and makes sure we don't shout
                            // about changed references
                            oldValue = source.NetCache.GetKeyedObject(newObjectKey);
                        }
                        if (lateSet)
                        {
                            source.NetCache.SetKeyedObject(newObjectKey, value);
                            if (newTypeKey >= 0)
                            {
                                source.NetCache.SetKeyedObject(newTypeKey, type);
                            }
                        }
                    }
                    if (newObjectKey >= 0 && !lateSet && !ReferenceEquals(oldValue, value))
                    {
                        throw new ProtoException("A reference-tracked object changed reference during deserialization");
                    }
                    if (newObjectKey < 0 && newTypeKey >= 0)
                    {      // have a new type, but not a new object
                        source.NetCache.SetKeyedObject(newTypeKey, type);
                    }
                    break;

                default:
                    source.SkipField();
                    break;
                }
            }
            if (newObjectKey >= 0 && (options & NetObjectOptions.AsReference) == 0)
            {
                throw new ProtoException("Object key in input stream, but reference-tracking was not expected");
            }
            ProtoReader.EndSubItem(token, source);

            return(value);
#endif
        }
Пример #28
0
        /// <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
        }
Пример #29
0
        private static long ReadTimeSpanTicks(ProtoReader source, out DateTimeKind kind)
        {
            kind = DateTimeKind.Unspecified;
            switch (source.WireType)
            {
            case WireType.String:
            case WireType.StartGroup:
                SubItemToken  token = ProtoReader.StartSubItem(source);
                int           fieldNumber;
                TimeSpanScale scale = TimeSpanScale.Days;
                long          value = 0;
                while ((fieldNumber = source.ReadFieldHeader()) > 0)
                {
                    switch (fieldNumber)
                    {
                    case FieldTimeSpanScale:
                        scale = (TimeSpanScale)source.ReadInt32();
                        break;

                    case FieldTimeSpanValue:
                        source.Assert(WireType.SignedVariant);
                        value = source.ReadInt64();
                        break;

                    case FieldTimeSpanKind:
                        kind = (DateTimeKind)source.ReadInt32();
                        switch (kind)
                        {
                        case DateTimeKind.Unspecified:
                        case DateTimeKind.Utc:
                        case DateTimeKind.Local:
                            break;             // fine

                        default:
                            throw new ProtoException("Invalid date/time kind: " + kind.ToString());
                        }
                        break;

                    default:
                        source.SkipField();
                        break;
                    }
                }
                ProtoReader.EndSubItem(token, source);
                switch (scale)
                {
                case TimeSpanScale.Days:
                    return(value * TimeSpan.TicksPerDay);

                case TimeSpanScale.Hours:
                    return(value * TimeSpan.TicksPerHour);

                case TimeSpanScale.Minutes:
                    return(value * TimeSpan.TicksPerMinute);

                case TimeSpanScale.Seconds:
                    return(value * TimeSpan.TicksPerSecond);

                case TimeSpanScale.Milliseconds:
                    return(value * TimeSpan.TicksPerMillisecond);

                case TimeSpanScale.Ticks:
                    return(value);

                case TimeSpanScale.MinMax:
                    switch (value)
                    {
                    case 1: return(long.MaxValue);

                    case -1: return(long.MinValue);

                    default: throw new ProtoException("Unknown min/max value: " + value.ToString());
                    }

                default:
                    throw new ProtoException("Unknown timescale: " + scale.ToString());
                }

            case WireType.Fixed64:
                return(source.ReadInt64());

            default:
                throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
            }
        }
Пример #30
0
 protected private abstract void ImplEndLengthPrefixedSubItem(ref State state, SubItemToken token, PrefixStyle style);
Пример #31
0
 /// <summary>
 /// Indicates the end of a nested record.
 /// </summary>
 /// <param name="token">The token obtained from StartubItem.</param>
 /// <param name="writer">The destination.</param>
 public static void EndSubItem(SubItemToken token, ProtoWriter writer)
 {
     EndSubItem(token, writer, PrefixStyle.Base128);
 }
Пример #32
0
 public static void EndSubItem(SubItemToken token, ProtoReader reader)
 {
     if (reader == null)
     {
         throw new ArgumentNullException("reader");
     }
     int value = token.value;
     WireType wireType = reader.wireType;
     if (wireType != WireType.EndGroup)
     {
         if (value < reader.position)
         {
             throw reader.CreateException("Sub-message not read entirely");
         }
         if (reader.blockEnd != reader.position && reader.blockEnd != 2147483647)
         {
             throw reader.CreateException("Sub-message not read correctly");
         }
         reader.blockEnd = value;
         reader.depth--;
     }
     else
     {
         if (value >= 0)
         {
             throw ProtoReader.AddErrorData(new ArgumentException("token"), reader);
         }
         if (-value != reader.fieldNumber)
         {
             throw reader.CreateException("Wrong group was ended");
         }
         reader.wireType = WireType.None;
         reader.depth--;
     }
 }
Пример #33
0
 private static SubItemToken StartSubItem(object instance, ProtoWriter writer, bool allowFixed)
 {
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     if (++writer.depth > 25)
     {
         writer.CheckRecursionStackAndPush(instance);
     }
     if (writer.packedFieldNumber != 0)
     {
         throw new InvalidOperationException("Cannot begin a sub-item while performing packed encoding");
     }
     switch (writer.wireType)
     {
     case WireType.String:
         writer.wireType = WireType.None;
         ProtoWriter.DemandSpace(32, writer);
         writer.flushLock++;
         writer.position++;
         return new SubItemToken(writer.ioIndex++);
     case WireType.StartGroup:
         writer.wireType = WireType.None;
         return new SubItemToken(-writer.fieldNumber);
     case WireType.Fixed32:
     {
         if (!allowFixed)
         {
             throw ProtoWriter.CreateException(writer);
         }
         ProtoWriter.DemandSpace(32, writer);
         writer.flushLock++;
         SubItemToken result = new SubItemToken(writer.ioIndex);
         ProtoWriter.IncrementedAndReset(4, writer);
         return result;
     }
     }
     throw ProtoWriter.CreateException(writer);
 }
Пример #34
0
 private static SubItemToken StartSubItem(object instance, ProtoWriter writer, bool allowFixed)
 {
     if (++writer.depth > RecursionCheckDepth)
     {
         writer.CheckRecursionStackAndPush(instance);
     }
     if(writer.packedFieldNumber != 0) throw new InvalidOperationException("Cannot begin a sub-item while performing packed encoding");
     switch (writer.wireType)
     {
         case WireType.StartGroup:
             writer.wireType = WireType.None;
             return new SubItemToken(-writer.fieldNumber);
         case WireType.String:
             writer.wireType = WireType.None;
             DemandSpace(32, writer); // make some space in anticipation...
             writer.flushLock++;
             writer.position++;
             return new SubItemToken(writer.ioIndex++); // leave 1 space (optimistic) for length
         case WireType.Fixed32:
             {
                 if (!allowFixed) throw CreateException(writer);
                 DemandSpace(32, writer); // make some space in anticipation...
                 writer.flushLock++;
                 SubItemToken token = new SubItemToken(writer.ioIndex);
                 ProtoWriter.IncrementedAndReset(4, writer); // leave 4 space (rigid) for length
                 return token;
             }
         default:
             throw CreateException(writer);
     }
 }
Пример #35
0
 /// <summary>
 /// Makes the end of consuming a nested message in the stream; the stream must be either at the correct EndGroup
 /// marker, or all fields of the sub-message must have been consumed (in either case, this means ReadFieldHeader
 /// should return zero)
 /// </summary>
 public static void EndSubItem(SubItemToken token, ProtoReader reader)
 {
     int value = token.value;
     switch (reader.wireType)
     {
         case WireType.EndGroup:
             if (value >= 0) throw AddErrorData(new ArgumentException("token"), reader);
             if (-value != reader.fieldNumber) throw reader.CreateException(); // wrong group ended!
             reader.wireType = WireType.None; // this releases ReadFieldHeader
             reader.depth--;
             break;
         // case WireType.None: // TODO reinstate once reads reset the wire-type
         default:
             if (value < reader.position) throw reader.CreateException();
             if (reader.blockEnd != reader.position && reader.blockEnd != int.MaxValue) throw reader.CreateException();
             reader.blockEnd = value;
             reader.depth--;
             break;
         /*default:
             throw reader.BorkedIt(); */
     }
 }
Пример #36
0
        private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
        {
            if (writer.wireType != WireType.None) { throw CreateException(writer); }
            int value = token.value;
            if (writer.depth <= 0) throw CreateException(writer);
            if (writer.depth-- > RecursionCheckDepth)
            {
                writer.PopRecursionStack();
            }
            writer.packedFieldNumber = 0; // ending the sub-item always wipes packed encoding
            if (value < 0)
            {   // group - very simple append
                WriteHeaderCore(-value, WireType.EndGroup, writer);
                writer.wireType = WireType.None;
                return;
            }

            // so we're backfilling the length into an existing sequence
            int len;
            switch(style)
            {
                case PrefixStyle.Fixed32:
                    len = (int)((writer.ioIndex - value) - 4);
                    ProtoWriter.WriteInt32ToBuffer(len, writer.ioBuffer, value);
                    break;
                case PrefixStyle.Fixed32BigEndian:
                    len = (int)((writer.ioIndex - value) - 4);
                    byte[] buffer = writer.ioBuffer;
                    ProtoWriter.WriteInt32ToBuffer(len, buffer, value);
                    // and swap the byte order
                    byte b = buffer[value];
                    buffer[value] = buffer[value + 3];
                    buffer[value + 3] = b;
                    b = buffer[value + 1];
                    buffer[value + 1] = buffer[value + 2];
                    buffer[value + 2] = b;
                    break;
                case PrefixStyle.Base128:
                    // string - complicated because we only reserved one byte;
                    // if the prefix turns out to need more than this then
                    // we need to shuffle the existing data
                    len = (int)((writer.ioIndex - value) - 1);
                    int offset = 0;
                    uint tmp = (uint)len;
                    while ((tmp >>= 7) != 0) offset++;
                    if (offset == 0)
                    {
                        writer.ioBuffer[value] = (byte)(len & 0x7F);
                    }
                    else
                    {
                        DemandSpace(offset, writer);
                        byte[] blob = writer.ioBuffer;
                        Helpers.BlockCopy(blob, value + 1, blob, value + 1 + offset, len);
                        tmp = (uint)len;
                        do
                        {
                            blob[value++] = (byte)((tmp & 0x7F) | 0x80);
                        } while ((tmp >>= 7) != 0);
                        blob[value - 1] = (byte)(blob[value - 1] & ~0x80);
                        writer.position += offset;
                        writer.ioIndex += offset;
                    }
                    break;
                default:
                    throw new ArgumentOutOfRangeException("style");
            }
            // and this object is no longer a blockage
            writer.flushLock--;
        }
Пример #37
0
 private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
 {
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     if (writer.wireType != WireType.None)
     {
         throw ProtoWriter.CreateException(writer);
     }
     int value = token.value;
     if (writer.depth <= 0)
     {
         throw ProtoWriter.CreateException(writer);
     }
     if (writer.depth-- > 25)
     {
         writer.PopRecursionStack();
     }
     writer.packedFieldNumber = 0;
     if (value < 0)
     {
         ProtoWriter.WriteHeaderCore(-value, WireType.EndGroup, writer);
         writer.wireType = WireType.None;
         return;
     }
     switch (style)
     {
     case PrefixStyle.Base128:
     {
         int num = writer.ioIndex - value - 1;
         int num2 = 0;
         uint num3 = (uint)num;
         while ((num3 >>= 7) != 0u)
         {
             num2++;
         }
         if (num2 == 0)
         {
             writer.ioBuffer[value] = (byte)(num & 127);
         }
         else
         {
             ProtoWriter.DemandSpace(num2, writer);
             byte[] array = writer.ioBuffer;
             Helpers.BlockCopy(array, value + 1, array, value + 1 + num2, num);
             num3 = (uint)num;
             do
             {
                 array[value++] = (byte)((num3 & 127u) | 128u);
             }
             while ((num3 >>= 7) != 0u);
             array[value - 1] = (byte)((int)array[value - 1] & -129);
             writer.position += num2;
             writer.ioIndex += num2;
         }
         break;
     }
     case PrefixStyle.Fixed32:
     {
         int num = writer.ioIndex - value - 4;
         ProtoWriter.WriteInt32ToBuffer(num, writer.ioBuffer, value);
         break;
     }
     case PrefixStyle.Fixed32BigEndian:
     {
         int num = writer.ioIndex - value - 4;
         byte[] array2 = writer.ioBuffer;
         ProtoWriter.WriteInt32ToBuffer(num, array2, value);
         byte b = array2[value];
         array2[value] = array2[value + 3];
         array2[value + 3] = b;
         b = array2[value + 1];
         array2[value + 1] = array2[value + 2];
         array2[value + 2] = b;
         break;
     }
     default:
         throw new ArgumentOutOfRangeException("style");
     }
     if (--writer.flushLock == 0 && writer.ioIndex >= 1024)
     {
         ProtoWriter.Flush(writer);
     }
 }