Exemple #1
0
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_questStepCompleteFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _questStepCompleteFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 8: {
                        result.hasIsQuestComplete = input.ReadBool(ref result.isQuestComplete_);
                        break;
                    }

                    case 18: {
                        global::D3.Quests.QuestReward.Builder subBuilder = global::D3.Quests.QuestReward.CreateBuilder();
                        if (result.hasReward)
                        {
                            subBuilder.MergeFrom(Reward);
                        }
                        input.ReadMessage(subBuilder, extensionRegistry);
                        Reward = subBuilder.BuildPartial();
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
                public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
                {
                    PrepareBuilder();
                    pb::UnknownFieldSet.Builder unknownFields = null;
                    uint   tag;
                    string field_name;

                    while (input.ReadTag(out tag, out field_name))
                    {
                        if (tag == 0 && field_name != null)
                        {
                            int field_ordinal = global::System.Array.BinarySearch(_s2CFieldNames, field_name, global::System.StringComparer.Ordinal);
                            if (field_ordinal >= 0)
                            {
                                tag = _s2CFieldTags[field_ordinal];
                            }
                            else
                            {
                                if (unknownFields == null)
                                {
                                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                }
                                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                                continue;
                            }
                        }
                        switch (tag)
                        {
                        case 0: {
                            throw pb::InvalidProtocolBufferException.InvalidTag();
                        }

                        default: {
                            if (pb::WireFormat.IsEndGroupTag(tag))
                            {
                                if (unknownFields != null)
                                {
                                    this.UnknownFields = unknownFields.Build();
                                }
                                return(this);
                            }
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            break;
                        }

                        case 10: {
                            global::Futu.OpenApi.Pb.QotCommon.Security.Builder subBuilder = global::Futu.OpenApi.Pb.QotCommon.Security.CreateBuilder();
                            if (result.hasSecurity)
                            {
                                subBuilder.MergeFrom(Security);
                            }
                            input.ReadMessage(subBuilder, extensionRegistry);
                            Security = subBuilder.BuildPartial();
                            break;
                        }

                        case 18: {
                            global::Futu.OpenApi.Pb.QotCommon.OrderDetail.Builder subBuilder = global::Futu.OpenApi.Pb.QotCommon.OrderDetail.CreateBuilder();
                            if (result.hasOrderDetailAsk)
                            {
                                subBuilder.MergeFrom(OrderDetailAsk);
                            }
                            input.ReadMessage(subBuilder, extensionRegistry);
                            OrderDetailAsk = subBuilder.BuildPartial();
                            break;
                        }

                        case 26: {
                            global::Futu.OpenApi.Pb.QotCommon.OrderDetail.Builder subBuilder = global::Futu.OpenApi.Pb.QotCommon.OrderDetail.CreateBuilder();
                            if (result.hasOrderDetailBid)
                            {
                                subBuilder.MergeFrom(OrderDetailBid);
                            }
                            input.ReadMessage(subBuilder, extensionRegistry);
                            OrderDetailBid = subBuilder.BuildPartial();
                            break;
                        }
                        }
                    }

                    if (unknownFields != null)
                    {
                        this.UnknownFields = unknownFields.Build();
                    }
                    return(this);
                }
 public static Response ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed());
 }
                public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
                {
                    PrepareBuilder();
                    pb::UnknownFieldSet.Builder unknownFields = null;
                    uint   tag;
                    string field_name;

                    while (input.ReadTag(out tag, out field_name))
                    {
                        if (tag == 0 && field_name != null)
                        {
                            int field_ordinal = global::System.Array.BinarySearch(_responseFieldNames, field_name, global::System.StringComparer.Ordinal);
                            if (field_ordinal >= 0)
                            {
                                tag = _responseFieldTags[field_ordinal];
                            }
                            else
                            {
                                if (unknownFields == null)
                                {
                                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                }
                                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                                continue;
                            }
                        }
                        switch (tag)
                        {
                        case 0: {
                            throw pb::InvalidProtocolBufferException.InvalidTag();
                        }

                        default: {
                            if (pb::WireFormat.IsEndGroupTag(tag))
                            {
                                if (unknownFields != null)
                                {
                                    this.UnknownFields = unknownFields.Build();
                                }
                                return(this);
                            }
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            break;
                        }

                        case 8: {
                            result.hasRetType = input.ReadInt32(ref result.retType_);
                            break;
                        }

                        case 18: {
                            result.hasRetMsg = input.ReadString(ref result.retMsg_);
                            break;
                        }

                        case 24: {
                            result.hasErrCode = input.ReadInt32(ref result.errCode_);
                            break;
                        }

                        case 34: {
                            global::Futu.OpenApi.Pb.QotUpdateOrderDetail.S2C.Builder subBuilder = global::Futu.OpenApi.Pb.QotUpdateOrderDetail.S2C.CreateBuilder();
                            if (result.hasS2C)
                            {
                                subBuilder.MergeFrom(S2C);
                            }
                            input.ReadMessage(subBuilder, extensionRegistry);
                            S2C = subBuilder.BuildPartial();
                            break;
                        }
                        }
                    }

                    if (unknownFields != null)
                    {
                        this.UnknownFields = unknownFields.Build();
                    }
                    return(this);
                }
 public static S2C ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
Exemple #6
0
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_fooWithExtraFieldsFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _fooWithExtraFieldsFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 8: {
                        input.ReadInt32(ref result.int32Value_);
                        break;
                    }

                    case 16: {
                        object unknown;
                        if (input.ReadEnum(ref result.enumValue_, out unknown))
                        {
                        }
                        else if (unknown is int)
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            unknownFields.MergeVarintField(2, (ulong)(int)unknown);
                        }
                        break;
                    }

                    case 24: {
                        input.ReadInt32(ref result.extraInt32Value_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
 public static GetDocumentsCommand ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
Exemple #8
0
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_savedAttributesFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _savedAttributesFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 10: {
                        global::D3.GameBalance.Handle.Builder subBuilder = global::D3.GameBalance.Handle.CreateBuilder();
                        if (result.hasGbHandle)
                        {
                            subBuilder.MergeFrom(GbHandle);
                        }
                        input.ReadMessage(subBuilder, extensionRegistry);
                        GbHandle = subBuilder.BuildPartial();
                        break;
                    }

                    case 18: {
                        input.ReadMessageArray(tag, field_name, result.attributes_, global::D3.AttributeSerializer.SavedAttribute.DefaultInstance, extensionRegistry);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
Exemple #9
0
 public static A9997ClientConnectionResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
Exemple #10
0
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_searchForPublicGameParamsFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _searchForPublicGameParamsFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 8: {
                        result.hasStartTime = input.ReadSInt64(ref result.startTime_);
                        break;
                    }

                    case 16: {
                        result.hasSecondsToSearch = input.ReadUInt32(ref result.secondsToSearch_);
                        break;
                    }

                    case 26: {
                        global::D3.OnlineService.GameCreateParams.Builder subBuilder = global::D3.OnlineService.GameCreateParams.CreateBuilder();
                        if (result.hasGameParams)
                        {
                            subBuilder.MergeFrom(GameParams);
                        }
                        input.ReadMessage(subBuilder, extensionRegistry);
                        GameParams = subBuilder.BuildPartial();
                        break;
                    }

                    case 32: {
                        result.hasRemoveReason = input.ReadInt32(ref result.removeReason_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
Exemple #11
0
 public static SavedAttributes ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
Exemple #12
0
 public static SearchForPublicGameParams ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
Exemple #13
0
 public static SearchForPublicGameParams ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
Exemple #14
0
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_queryBuilderFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _queryBuilderFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 10: {
                        result.hasQuery = input.ReadString(ref result.query_);
                        break;
                    }

                    case 18: {
                        input.ReadMessageArray(tag, field_name, result.parameters_, global::Alachisoft.NosDB.Common.Protobuf.Parameter.DefaultInstance, extensionRegistry);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
Exemple #15
0
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_a1013ResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _a1013ResponseFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 10: {
                        result.hasErrorInfo = input.ReadString(ref result.errorInfo_);
                        break;
                    }

                    case 16: {
                        result.hasErrorCode = input.ReadInt32(ref result.errorCode_);
                        break;
                    }

                    case 26: {
                        result.hasUid = input.ReadString(ref result.uid_);
                        break;
                    }

                    case 58: {
                        input.ReadMessageArray(tag, field_name, result.users_, global::DolphinServer.ProtoEntity.A1013User.DefaultInstance, extensionRegistry);
                        break;
                    }

                    case 64: {
                        result.hasNiaoCard1 = input.ReadInt32(ref result.niaoCard1_);
                        break;
                    }

                    case 72: {
                        result.hasNiaoCard2 = input.ReadInt32(ref result.niaoCard2_);
                        break;
                    }

                    case 82: {
                        result.hasNiaoUid1 = input.ReadString(ref result.niaoUid1_);
                        break;
                    }

                    case 90: {
                        result.hasNiaoUid2 = input.ReadString(ref result.niaoUid2_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
Exemple #16
0
 public static A9997ClientConnectionResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
Exemple #17
0
 public static FooWithExtraFields ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
Exemple #18
0
 public static ImportMessageLite ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
 public static GetDocumentsCommand ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
        public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            PrepareBuilder();
            pb::UnknownFieldSet.Builder unknownFields = null;
            uint   tag;
            string field_name;

            while (input.ReadTag(out tag, out field_name))
            {
                if (tag == 0 && field_name != null)
                {
                    int field_ordinal = global::System.Array.BinarySearch(_selectionEnvelopeFieldNames, field_name,
                                                                          global::System.StringComparer.Ordinal);
                    if (field_ordinal >= 0)
                    {
                        tag = _selectionEnvelopeFieldTags[field_ordinal];
                    }
                    else
                    {
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        continue;
                    }
                }
                switch (tag)
                {
                case 0:
                {
                    throw pb::InvalidProtocolBufferException.InvalidTag();
                }

                default:
                {
                    if (pb::WireFormat.IsEndGroupTag(tag))
                    {
                        if (unknownFields != null)
                        {
                            this.UnknownFields = unknownFields.Build();
                        }
                        return(this);
                    }
                    if (unknownFields == null)
                    {
                        unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                    }
                    ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                    break;
                }

                case 10:
                {
                    result.hasEnclosedMessage = input.ReadBytes(ref result.enclosedMessage_);
                    break;
                }

                case 16:
                {
                    result.hasSerializerId = input.ReadInt32(ref result.serializerId_);
                    break;
                }

                case 26:
                {
                    input.ReadMessageArray(tag, field_name, result.pattern_, global::Selection.DefaultInstance,
                                           extensionRegistry);
                    break;
                }

                case 34:
                {
                    result.hasMessageManifest = input.ReadBytes(ref result.messageManifest_);
                    break;
                }
                }
            }

            if (unknownFields != null)
            {
                this.UnknownFields = unknownFields.Build();
            }
            return(this);
        }
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_getDocumentsCommandFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _getDocumentsCommandFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 10: {
                        input.ReadStringArray(tag, field_name, result.documentIds_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
Exemple #22
0
 public static GameProperties ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
 public static void RegisterAllExtensions(pb::ExtensionRegistry registry)
 {
 }
Exemple #24
0
            public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                pb::UnknownFieldSet.Builder unknownFields = null;
                while (true)
                {
                    uint tag = input.ReadTag();
                    switch (tag)
                    {
                    case 0: {
                        if (unknownFields != null)
                        {
                            this.UnknownFields = unknownFields.Build();
                        }
                        return(this);
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag);
                        break;
                    }

                    case 10: {
                        global::bnet.protocol.attribute.AttributeFilter.Builder subBuilder = global::bnet.protocol.attribute.AttributeFilter.CreateBuilder();
                        if (HasFilter)
                        {
                            subBuilder.MergeFrom(Filter);
                        }
                        input.ReadMessage(subBuilder, extensionRegistry);
                        Filter = subBuilder.BuildPartial();
                        break;
                    }

                    case 16: {
                        Create = input.ReadBool();
                        break;
                    }

                    case 24: {
                        Open = input.ReadBool();
                        break;
                    }

                    case 37: {
                        ProgramId = input.ReadFixed32();
                        break;
                    }
                    }
                }
            }
 public static S2C ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
        static UnitTestExtrasProtoFile()
        {
            byte[] descriptorData = global::System.Convert.FromBase64String(
                string.Concat(
                    "ChxleHRlc3QvdW5pdHRlc3RfZXh0cmFzLnByb3RvEhdwcm90b2J1Zl91bml0",
                    "dGVzdF9leHRyYRokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9vcHRpb25zLnBy",
                    "b3RvIiIKFlRlc3RVbnBhY2tlZEV4dGVuc2lvbnMqCAgBEICAgIACKlIKHVVu",
                    "cGFja2VkRXh0ZW5zaW9uc0ZvcmVpZ25FbnVtEg8KC0ZPUkVJR05fRk9PEAQS",
                    "DwoLRk9SRUlHTl9CQVIQBRIPCgtGT1JFSUdOX0JBWhAGOlEKGHVucGFja2Vk",
                    "X2ludDMyX2V4dGVuc2lvbhIvLnByb3RvYnVmX3VuaXR0ZXN0X2V4dHJhLlRl",
                    "c3RVbnBhY2tlZEV4dGVuc2lvbnMYWiADKAU6UQoYdW5wYWNrZWRfaW50NjRf",
                    "ZXh0ZW5zaW9uEi8ucHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFj",
                    "a2VkRXh0ZW5zaW9ucxhbIAMoAzpSChl1bnBhY2tlZF91aW50MzJfZXh0ZW5z",
                    "aW9uEi8ucHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0",
                    "ZW5zaW9ucxhcIAMoDTpSChl1bnBhY2tlZF91aW50NjRfZXh0ZW5zaW9uEi8u",
                    "cHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9u",
                    "cxhdIAMoBDpSChl1bnBhY2tlZF9zaW50MzJfZXh0ZW5zaW9uEi8ucHJvdG9i",
                    "dWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxheIAMo",
                    "ETpSChl1bnBhY2tlZF9zaW50NjRfZXh0ZW5zaW9uEi8ucHJvdG9idWZfdW5p",
                    "dHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhfIAMoEjpTChp1",
                    "bnBhY2tlZF9maXhlZDMyX2V4dGVuc2lvbhIvLnByb3RvYnVmX3VuaXR0ZXN0",
                    "X2V4dHJhLlRlc3RVbnBhY2tlZEV4dGVuc2lvbnMYYCADKAc6UwoadW5wYWNr",
                    "ZWRfZml4ZWQ2NF9leHRlbnNpb24SLy5wcm90b2J1Zl91bml0dGVzdF9leHRy",
                    "YS5UZXN0VW5wYWNrZWRFeHRlbnNpb25zGGEgAygGOlQKG3VucGFja2VkX3Nm",
                    "aXhlZDMyX2V4dGVuc2lvbhIvLnByb3RvYnVmX3VuaXR0ZXN0X2V4dHJhLlRl",
                    "c3RVbnBhY2tlZEV4dGVuc2lvbnMYYiADKA86VAobdW5wYWNrZWRfc2ZpeGVk",
                    "NjRfZXh0ZW5zaW9uEi8ucHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVu",
                    "cGFja2VkRXh0ZW5zaW9ucxhjIAMoEDpRChh1bnBhY2tlZF9mbG9hdF9leHRl",
                    "bnNpb24SLy5wcm90b2J1Zl91bml0dGVzdF9leHRyYS5UZXN0VW5wYWNrZWRF",
                    "eHRlbnNpb25zGGQgAygCOlIKGXVucGFja2VkX2RvdWJsZV9leHRlbnNpb24S",
                    "Ly5wcm90b2J1Zl91bml0dGVzdF9leHRyYS5UZXN0VW5wYWNrZWRFeHRlbnNp",
                    "b25zGGUgAygBOlAKF3VucGFja2VkX2Jvb2xfZXh0ZW5zaW9uEi8ucHJvdG9i",
                    "dWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhmIAMo",
                    "CDqIAQoXdW5wYWNrZWRfZW51bV9leHRlbnNpb24SLy5wcm90b2J1Zl91bml0",
                    "dGVzdF9leHRyYS5UZXN0VW5wYWNrZWRFeHRlbnNpb25zGGcgAygOMjYucHJv",
                    "dG9idWZfdW5pdHRlc3RfZXh0cmEuVW5wYWNrZWRFeHRlbnNpb25zRm9yZWln",
                    "bkVudW1CVgoTY29tLmdvb2dsZS5wcm90b2J1ZsI+PgohR29vZ2xlLlByb3Rv",
                    "Y29sQnVmZmVycy5UZXN0UHJvdG9zEhdVbml0VGVzdEV4dHJhc1Byb3RvRmls",
                    "ZUgB"));
            pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
                descriptor = root;
                internal__static_protobuf_unittest_extra_TestUnpackedExtensions__Descriptor         = Descriptor.MessageTypes[0];
                internal__static_protobuf_unittest_extra_TestUnpackedExtensions__FieldAccessorTable =
                    new pb::FieldAccess.FieldAccessorTable <global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions, global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions.Builder>(internal__static_protobuf_unittest_extra_TestUnpackedExtensions__Descriptor,
                                                                                                                                                                                                        new string[] { });
                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedInt32Extension = pb::GeneratedRepeatExtension <int> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[0]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedInt64Extension = pb::GeneratedRepeatExtension <long> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[1]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedUint32Extension = pb::GeneratedRepeatExtension <uint> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[2]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedUint64Extension = pb::GeneratedRepeatExtension <ulong> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[3]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSint32Extension = pb::GeneratedRepeatExtension <int> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[4]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSint64Extension = pb::GeneratedRepeatExtension <long> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[5]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFixed32Extension = pb::GeneratedRepeatExtension <uint> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[6]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFixed64Extension = pb::GeneratedRepeatExtension <ulong> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[7]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSfixed32Extension = pb::GeneratedRepeatExtension <int> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[8]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSfixed64Extension = pb::GeneratedRepeatExtension <long> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[9]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFloatExtension = pb::GeneratedRepeatExtension <float> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[10]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedDoubleExtension = pb::GeneratedRepeatExtension <double> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[11]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedBoolExtension = pb::GeneratedRepeatExtension <bool> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[12]);

                global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedEnumExtension = pb::GeneratedRepeatExtension <global::Google.ProtocolBuffers.TestProtos.UnpackedExtensionsForeignEnum> .CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[13]);

                pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance();
                RegisterAllExtensions(registry);
                global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.RegisterAllExtensions(registry);
                return(registry);
            };
            pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
                                                               new pbd::FileDescriptor[] {
                global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor,
            }, assigner);
        }
 public static Response ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }
Exemple #28
0
            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint   tag;
                string field_name;

                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_a1013UserFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _a1013UserFieldTags[field_ordinal];
                        }
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                    case 0: {
                        throw pb::InvalidProtocolBufferException.InvalidTag();
                    }

                    default: {
                        if (pb::WireFormat.IsEndGroupTag(tag))
                        {
                            if (unknownFields != null)
                            {
                                this.UnknownFields = unknownFields.Build();
                            }
                            return(this);
                        }
                        if (unknownFields == null)
                        {
                            unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                        }
                        ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                        break;
                    }

                    case 10: {
                        result.hasUid = input.ReadString(ref result.uid_);
                        break;
                    }

                    case 16: {
                        result.hasScore = input.ReadInt32(ref result.score_);
                        break;
                    }

                    case 24: {
                        result.hasTotalScore = input.ReadInt32(ref result.totalScore_);
                        break;
                    }

                    case 32: {
                        result.hasHuType = input.ReadInt32(ref result.huType_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
 public static Response ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
Exemple #30
0
 public static QuestStepComplete ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed());
 }