public bool SkipField()
        {
            uint tag = this.lastTag;

            switch (WireFormat.GetTagWireType(tag))
            {
            case WireFormat.WireType.Varint:
                this.ReadRawVarint64();
                return(true);

            case WireFormat.WireType.Fixed64:
                this.ReadRawLittleEndian64();
                return(true);

            case WireFormat.WireType.LengthDelimited:
                this.SkipRawBytes((int)this.ReadRawVarint32());
                return(true);

            case WireFormat.WireType.StartGroup:
                this.SkipMessage();
                this.CheckLastTagWas(WireFormat.MakeTag(WireFormat.GetTagFieldNumber(tag), WireFormat.WireType.EndGroup));
                return(true);

            case WireFormat.WireType.EndGroup:
                return(false);

            case WireFormat.WireType.Fixed32:
                this.ReadRawLittleEndian32();
                return(true);

            default:
                throw InvalidProtocolBufferException.InvalidWireType();
            }
        }
 public void WriteUnknownField(int fieldNumber, WireFormat.WireType wireType, ulong value)
 {
     if (wireType == WireFormat.WireType.Varint)
     {
         WriteUInt64(fieldNumber, null /*not used*/, value);
     }
     else if (wireType == WireFormat.WireType.Fixed32)
     {
         WriteFixed32(fieldNumber, null /*not used*/, (uint)value);
     }
     else if (wireType == WireFormat.WireType.Fixed64)
     {
         WriteFixed64(fieldNumber, null /*not used*/, value);
     }
     else
     {
         throw InvalidProtocolBufferException.InvalidWireType();
     }
 }
Exemple #3
0
            public bool MergeFieldFrom(uint tag, CodedInputStream input)
            {
                int number = WireFormat.GetTagFieldNumber(tag);

                switch (WireFormat.GetTagWireType(tag))
                {
                case WireFormat.WireType.Varint:
                    GetFieldBuilder(number).AddVarint(input.ReadUInt64());
                    return(true);

                case WireFormat.WireType.Fixed64:
                    GetFieldBuilder(number).AddFixed64(input.ReadFixed64());
                    return(true);

                case WireFormat.WireType.LengthDelimited:
                    GetFieldBuilder(number).AddLengthDelimited(input.ReadBytes());
                    return(true);

                case WireFormat.WireType.StartGroup: {
                    Builder subBuilder = CreateBuilder();
#pragma warning disable 0612
                    input.ReadUnknownGroup(number, subBuilder);
#pragma warning restore 0612
                    GetFieldBuilder(number).AddGroup(subBuilder.Build());
                    return(true);
                }

                case WireFormat.WireType.EndGroup:
                    return(false);

                case WireFormat.WireType.Fixed32:
                    GetFieldBuilder(number).AddFixed32(input.ReadFixed32());
                    return(true);

                default:
                    throw InvalidProtocolBufferException.InvalidWireType();
                }
            }
Exemple #4
0
            /// <summary>
            /// Parse a single field from <paramref name="input"/> and merge it
            /// into this set.
            /// </summary>
            /// <param name="tag">The field's tag number, which was already parsed.</param>
            /// <param name="input">The coded input stream containing the field</param>
            /// <returns>false if the tag is an "end group" tag, true otherwise</returns>
            public bool MergeFieldFrom(uint tag, ICodedInputStream input)
            {
                if (tag == 0)
                {
                    input.SkipField();
                    return(true);
                }

                int number = WireFormat.GetTagFieldNumber(tag);

                switch (WireFormat.GetTagWireType(tag))
                {
                case WireFormat.WireType.Varint:
                {
                    ulong uint64 = 0;
                    if (input.ReadUInt64(ref uint64))
                    {
                        GetFieldBuilder(number).AddVarint(uint64);
                    }
                    return(true);
                }

                case WireFormat.WireType.Fixed32:
                {
                    uint uint32 = 0;
                    if (input.ReadFixed32(ref uint32))
                    {
                        GetFieldBuilder(number).AddFixed32(uint32);
                    }
                    return(true);
                }

                case WireFormat.WireType.Fixed64:
                {
                    ulong uint64 = 0;
                    if (input.ReadFixed64(ref uint64))
                    {
                        GetFieldBuilder(number).AddFixed64(uint64);
                    }
                    return(true);
                }

                case WireFormat.WireType.LengthDelimited:
                {
                    ByteString bytes = null;
                    if (input.ReadBytes(ref bytes))
                    {
                        GetFieldBuilder(number).AddLengthDelimited(bytes);
                    }
                    return(true);
                }

                case WireFormat.WireType.StartGroup:
                {
                    Builder subBuilder = CreateBuilder();
#pragma warning disable 0612
                    input.ReadUnknownGroup(number, subBuilder);
#pragma warning restore 0612
                    GetFieldBuilder(number).AddGroup(subBuilder.Build());
                    return(true);
                }

                case WireFormat.WireType.EndGroup:
                    return(false);

                default:
                    throw InvalidProtocolBufferException.InvalidWireType();
                }
            }