コード例 #1
0
ファイル: ItemCrafting.cs プロジェクト: yg7845333/mooege
 public static CrafterSavedData ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #2
0
 public static SavedAttributes ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #3
0
 public static A9997ClientConnectionResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #4
0
 public static ImportMessageLite ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #5
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(_savedAttributeFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _savedAttributeFieldTags[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.hasKey = input.ReadSInt32(ref result.key_);
                        break;
                    }

                    case 16: {
                        result.hasValue = input.ReadSInt32(ref result.value_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
コード例 #6
0
ファイル: PartyMessage.cs プロジェクト: RedMadKnight/d3proto
            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);
            }
コード例 #7
0
 public static DropSessionCommand ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #8
0
ファイル: Quest.cs プロジェクト: RedMadKnight/d3proto
 public static QuestStepComplete ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #9
0
ファイル: Quest.cs プロジェクト: RedMadKnight/d3proto
            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);
            }
コード例 #10
0
ファイル: GameFactory.cs プロジェクト: RedMadKnight/d3proto
            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(_gamePropertiesFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _gamePropertiesFieldTags[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::bnet.protocol.attribute.AttributeFilter.Builder subBuilder = global::bnet.protocol.attribute.AttributeFilter.CreateBuilder();
                        if (result.hasFilter)
                        {
                            subBuilder.MergeFrom(Filter);
                        }
                        input.ReadMessage(subBuilder, extensionRegistry);
                        Filter = subBuilder.BuildPartial();
                        break;
                    }

                    case 16: {
                        result.hasCreate = input.ReadBool(ref result.create_);
                        break;
                    }

                    case 24: {
                        result.hasOpen = input.ReadBool(ref result.open_);
                        break;
                    }

                    case 37: {
                        result.hasProgramId = input.ReadFixed32(ref result.programId_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }
コード例 #11
0
ファイル: Quest.cs プロジェクト: RedMadKnight/d3proto
 public static QuestStepComplete ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #12
0
ファイル: GameFactory.cs プロジェクト: RedMadKnight/d3proto
 public static GameProperties ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #13
0
ファイル: JobConfigProtos.cs プロジェクト: claq2/Proto
 public static GetJobConfigResponse ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #14
0
ファイル: JobConfigProtos.cs プロジェクト: claq2/Proto
 public static GetJobConfigRequest ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #15
0
ファイル: PartyMessage.cs プロジェクト: RedMadKnight/d3proto
 public static SearchForPublicGameParams ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #16
0
 public static WriteQueryCommand ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #17
0
ファイル: PartyMessage.cs プロジェクト: RedMadKnight/d3proto
 public static SearchForPublicGameParams ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #18
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(_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: {
                            input.ReadMessageArray(tag, field_name, result.tickerList_, global::Futu.OpenApi.Pb.QotCommon.Ticker.DefaultInstance, extensionRegistry);
                            break;
                        }
                        }
                    }

                    if (unknownFields != null)
                    {
                        this.UnknownFields = unknownFields.Build();
                    }
                    return(this);
                }
コード例 #19
0
 public static TestUnpackedExtensions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #20
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(_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.QotUpdateTicker.S2C.Builder subBuilder = global::Futu.OpenApi.Pb.QotUpdateTicker.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);
                }
コード例 #21
0
 public static DropSessionCommand ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #22
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);
            }
コード例 #23
0
 public static ImportMessageLite ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
 {
     return(((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed());
 }
コード例 #24
0
 public static Parameter ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #25
0
 public static SavedAttributes ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #26
0
 public static A1017Response ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #27
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);
            }
コード例 #28
0
ファイル: PartyMessage.cs プロジェクト: RedMadKnight/d3proto
 public static ScreenStatus ParseFrom(pb::ICodedInputStream input)
 {
     return(((Builder)CreateBuilder().MergeFrom(input)).BuildParsed());
 }
コード例 #29
0
 public override Builder MergeFrom(pb::ICodedInputStream input)
 {
     return(MergeFrom(input, pb::ExtensionRegistry.Empty));
 }
コード例 #30
0
ファイル: ItemCrafting.cs プロジェクト: yg7845333/mooege
            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(_crafterDataFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                        {
                            tag = _crafterDataFieldTags[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:
                    case 13: {
                        input.ReadSFixed32Array(tag, field_name, result.recipes_);
                        break;
                    }

                    case 18:
                    case 21: {
                        input.ReadSFixed32Array(tag, field_name, result.availableEnchants_);
                        break;
                    }

                    case 24: {
                        result.hasLevel = input.ReadInt32(ref result.level_);
                        break;
                    }

                    case 33: {
                        result.hasCooldownEnd = input.ReadSFixed64(ref result.cooldownEnd_);
                        break;
                    }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return(this);
            }