CheckReadEndOfStreamTag() private method

Verifies that the last call to ReadTag() returned tag 0 - in other words, we've reached the end of the stream when we expected to.
The /// tag read was not the one specified
private CheckReadEndOfStreamTag ( ) : void
return void
Example #1
0
        public static void MergeFrom(this IMessage message, Stream input)
        {
            Preconditions.CheckNotNull <IMessage>(message, Module.smethod_35 <string>(2616444679u));
            Preconditions.CheckNotNull <Stream>(input, Module.smethod_34 <string>(3703866810u));
            CodedInputStream codedInputStream;

            while (true)
            {
IL_5C:
                uint arg_44_0 = 1463404901u;
                while (true)
                {
                    uint num;
                    switch ((num = (arg_44_0 ^ 561544202u)) % 3u)
                    {
                    case 0u:
                        goto IL_5C;

                    case 1u:
                        codedInputStream = new CodedInputStream(input);
                        message.MergeFrom(codedInputStream);
                        arg_44_0 = (num * 1287290389u ^ 4230433120u);
                        continue;
                    }
                    goto Block_1;
                }
            }
Block_1:
            codedInputStream.CheckReadEndOfStreamTag();
        }
Example #2
0
 /// <summary>
 /// Merges data from the given byte array into an existing message.
 /// </summary>
 /// <param name="message">The message to merge the data into.</param>
 /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param>
 public static void MergeFrom(this IMessage message, byte[] data)
 {
     ProtoPreconditions.CheckNotNull(message, "message");
     ProtoPreconditions.CheckNotNull(data, "data");
     CodedInputStream input = new CodedInputStream(data);
     message.MergeFrom(input);
     input.CheckReadEndOfStreamTag();
 }
Example #3
0
 /// <summary>
 /// Merges data from the given stream into an existing message.
 /// </summary>
 /// <param name="message">The message to merge the data into.</param>
 /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param>
 public static void MergeFrom(this IMessage message, Stream input)
 {
     ProtoPreconditions.CheckNotNull(message, "message");
     ProtoPreconditions.CheckNotNull(input, "input");
     CodedInputStream codedInput = new CodedInputStream(input);
     message.MergeFrom(codedInput);
     codedInput.CheckReadEndOfStreamTag();
 }
Example #4
0
        /// <summary>
        /// Merges data from the given stream into an existing message.
        /// </summary>
        /// <param name="message">The message to merge the data into.</param>
        /// <param name="input">Stream containing the data to merge, which must be protobuf-encoded binary data.</param>
        public static void MergeFrom(this IMessage message, Stream input)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(input, "input");
            CodedInputStream codedInput = new CodedInputStream(input);

            message.MergeFrom(codedInput);
            codedInput.CheckReadEndOfStreamTag();
        }
Example #5
0
        /// <summary>
        /// Merges data from the given byte string into an existing message.
        /// </summary>
        /// <param name="message">The message to merge the data into.</param>
        /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param>
        public static void MergeFrom(this IMessage message, ByteString data)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(data, "data");
            CodedInputStream input = data.CreateCodedInput();

            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #6
0
        /// <summary>
        /// Merges data from the given byte array slice into an existing message.
        /// </summary>
        /// <param name="message">The message to merge the data into.</param>
        /// <param name="data">The data containing the slice to merge, which must be protobuf-encoded binary data.</param>
        /// <param name="offset">The offset of the slice to merge.</param>
        /// <param name="length">The length of the slice to merge.</param>
        public static void MergeFrom(this IMessage message, byte[] data, int offset, int length)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(data, "data");
            CodedInputStream input = new CodedInputStream(data, offset, length);

            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #7
0
        internal static void MergeFrom(this IMessage message, Stream input, bool discardUnknownFields)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(input, "input");
            CodedInputStream codedInput = new CodedInputStream(input);

            codedInput.DiscardUnknownFields = discardUnknownFields;
            message.MergeFrom(codedInput);
            codedInput.CheckReadEndOfStreamTag();
        }
Example #8
0
        internal static void MergeFrom(this IMessage message, ByteString data, bool discardUnknownFields)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(data, "data");
            CodedInputStream input = data.CreateCodedInput();

            input.DiscardUnknownFields = discardUnknownFields;
            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #9
0
        internal static void MergeFrom(this IMessage message, byte[] data, int offset, int length, bool discardUnknownFields)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(data, "data");
            CodedInputStream input = new CodedInputStream(data, offset, length);

            input.DiscardUnknownFields = discardUnknownFields;
            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #10
0
        /// <summary>
        /// Merges data from the given byte array into an existing message.
        /// </summary>
        /// <param name="message">The message to merge the data into.</param>
        /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param>
        public static void MergeFrom(this IMessage message, byte[] data)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(data, "data");
            inputStream.Reset(data, 0, data.Length);
            CodedInputStream input = inputStream;

            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #11
0
        // Implementations allowing unknown fields to be discarded.
        internal static void MergeFrom(this IMessage message, byte[] data, bool discardUnknownFields, ExtensionRegistry registry)
        {
            ProtoPreconditions.CheckNotNull(message, "message");
            ProtoPreconditions.CheckNotNull(data, "data");
            CodedInputStream input = new CodedInputStream(data);

            input.DiscardUnknownFields = discardUnknownFields;
            input.ExtensionRegistry    = registry;
            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #12
0
        internal static void MergeFrom(this IMessage message, ByteString data, bool discardUnknownFields, ExtensionRegistry registry)
        {
            ProtoPreconditions.CheckNotNull(message, nameof(message));
            ProtoPreconditions.CheckNotNull(data, nameof(data));
            CodedInputStream input = data.CreateCodedInput();

            input.DiscardUnknownFields = discardUnknownFields;
            input.ExtensionRegistry    = registry;
            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #13
0
        internal static void MergeFrom(this IMessage message, Stream input, bool discardUnknownFields, ExtensionRegistry registry)
        {
            ProtoPreconditions.CheckNotNull(message, nameof(message));
            ProtoPreconditions.CheckNotNull(input, nameof(input));
            CodedInputStream codedInput = new CodedInputStream(input)
            {
                DiscardUnknownFields = discardUnknownFields,
                ExtensionRegistry    = registry
            };

            message.MergeFrom(codedInput);
            codedInput.CheckReadEndOfStreamTag();
        }
Example #14
0
        internal static void MergeFrom(this IMessage message, byte[] data, int offset, int length, bool discardUnknownFields, ExtensionRegistry registry)
        {
            ProtoPreconditions.CheckNotNull(message, nameof(message));
            ProtoPreconditions.CheckNotNull(data, nameof(data));
            CodedInputStream input = new CodedInputStream(data, offset, length)
            {
                DiscardUnknownFields = discardUnknownFields,
                ExtensionRegistry    = registry
            };

            message.MergeFrom(input);
            input.CheckReadEndOfStreamTag();
        }
Example #15
0
            internal static T Read <T>(CodedInputStream input, FieldCodec <T> codec)
            {
                int length   = input.ReadLength();
                int oldLimit = input.PushLimit(length);

                uint tag;
                T    value = codec.DefaultValue;

                while ((tag = input.ReadTag()) != 0)
                {
                    if (tag == codec.Tag)
                    {
                        value = codec.Read(input);
                    }
                    else
                    {
                        input.SkipLastField();
                    }
                }
                input.CheckReadEndOfStreamTag();
                input.PopLimit(oldLimit);

                return(value);
            }
Example #16
0
            internal static T Read <T>(CodedInputStream input, FieldCodec <T> codec)
            {
                int byteLimit = input.ReadLength();
                T   result;

                while (true)
                {
IL_FA:
                    uint arg_C8_0 = 1476935752u;
                    while (true)
                    {
                        uint num;
                        switch ((num = (arg_C8_0 ^ 2018772964u)) % 9u)
                        {
                        case 0u:
                            input.SkipLastField();
                            arg_C8_0 = 1768391466u;
                            continue;

                        case 1u:
                        {
                            uint num2;
                            arg_C8_0 = (((num2 = input.ReadTag()) == 0u) ? 789788880u : 1000495088u);
                            continue;
                        }

                        case 3u:
                            arg_C8_0 = (num * 422428889u ^ 15908708u);
                            continue;

                        case 4u:
                            result   = codec.Read(input);
                            arg_C8_0 = (num * 2015424451u ^ 1456283564u);
                            continue;

                        case 5u:
                        {
                            uint num2;
                            arg_C8_0 = ((num2 == codec.Tag) ? 627669222u : 345821031u);
                            continue;
                        }

                        case 6u:
                        {
                            input.CheckReadEndOfStreamTag();
                            int oldLimit;
                            input.PopLimit(oldLimit);
                            arg_C8_0 = (num * 1368242210u ^ 1133084529u);
                            continue;
                        }

                        case 7u:
                        {
                            int oldLimit = input.PushLimit(byteLimit);
                            result   = codec.DefaultValue;
                            arg_C8_0 = (num * 2466023856u ^ 3651674u);
                            continue;
                        }

                        case 8u:
                            goto IL_FA;
                        }
                        return(result);
                    }
                }
                return(result);
            }