public void MergeFrom(pb::CodedInputStream input)
        {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
            input.ReadRawMessage(this);
    #else
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    Name = input.ReadString();
                    break;
                }

                case 18: {
                    labels_.AddEntriesFrom(input, _map_labels_codec);
                    break;
                }

                case 34: {
                    if (createTime_ == null)
                    {
                        CreateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp();
                    }
                    input.ReadMessage(CreateTime);
                    break;
                }

                case 42: {
                    if (updateTime_ == null)
                    {
                        UpdateTime = new global::Google.Protobuf.WellKnownTypes.Timestamp();
                    }
                    input.ReadMessage(UpdateTime);
                    break;
                }
                }
            }
    #endif
        }
Example #2
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    Name = input.ReadString();
                    break;
                }

                case 18: {
                    BasePath = input.ReadString();
                    break;
                }

                case 24: {
                    ModelType = (global::Tensorflow.Serving.ModelType)input.ReadEnum();
                    break;
                }

                case 34: {
                    ModelPlatform = input.ReadString();
                    break;
                }

                case 50: {
                    if (loggingConfig_ == null)
                    {
                        LoggingConfig = new global::Tensorflow.Serving.LoggingConfig();
                    }
                    input.ReadMessage(LoggingConfig);
                    break;
                }

                case 58: {
                    if (modelVersionPolicy_ == null)
                    {
                        ModelVersionPolicy = new global::Tensorflow.Serving.FileSystemStoragePathSourceConfig.Types.ServableVersionPolicy();
                    }
                    input.ReadMessage(ModelVersionPolicy);
                    break;
                }

                case 66: {
                    versionLabels_.AddEntriesFrom(input, _map_versionLabels_codec);
                    break;
                }
                }
            }
        }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    if (builder_ == null)
                    {
                        Builder = new global::Estafette.Ci.Manifest.V1.EstafetteBuilder();
                    }
                    input.ReadMessage(Builder);
                    break;
                }

                case 18: {
                    labels_.AddEntriesFrom(input, _map_labels_codec);
                    break;
                }

                case 26: {
                    if (version_ == null)
                    {
                        Version = new global::Estafette.Ci.Manifest.V1.EstafetteVersion();
                    }
                    input.ReadMessage(Version);
                    break;
                }

                case 34: {
                    globalEnvVars_.AddEntriesFrom(input, _map_globalEnvVars_codec);
                    break;
                }

                case 42: {
                    triggers_.AddEntriesFrom(input, _repeated_triggers_codec);
                    break;
                }

                case 50: {
                    stages_.AddEntriesFrom(input, _repeated_stages_codec);
                    break;
                }

                case 58: {
                    releases_.AddEntriesFrom(input, _repeated_releases_codec);
                    break;
                }
                }
            }
        }
Example #4
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    Id = input.ReadString();
                    break;
                }

                case 18: {
                    ClassId = input.ReadString();
                    break;
                }

                case 24: {
                    Protocol = (global::PKIo.PassProtocol)input.ReadEnum();
                    break;
                }

                case 34: {
                    if (personDetails_ == null)
                    {
                        PersonDetails = new global::PKIo.Person();
                    }
                    input.ReadMessage(PersonDetails);
                    break;
                }

                case 42: {
                    if (metadata_ == null)
                    {
                        Metadata = new global::PKIo.Metadata();
                    }
                    input.ReadMessage(Metadata);
                    break;
                }

                case 50: {
                    recordData_.AddEntriesFrom(input, _map_recordData_codec);
                    break;
                }

                case 58: {
                    ExternalId = input.ReadString();
                    break;
                }
                }
            }
        }
Example #5
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (header_ == null)
                    {
                        header_ = new global::Apollo.Common.Header();
                    }
                    input.ReadMessage(header_);
                    break;
                }

                case 18: {
                    if (hdmap_ == null)
                    {
                        hdmap_ = new global::Apollo.Hdmap.Map();
                    }
                    input.ReadMessage(hdmap_);
                    break;
                }

                case 26: {
                    navigationPath_.AddEntriesFrom(input, _map_navigationPath_codec);
                    break;
                }

                case 34: {
                    if (laneMarker_ == null)
                    {
                        laneMarker_ = new global::Apollo.Perception.LaneMarkers();
                    }
                    input.ReadMessage(laneMarker_);
                    break;
                }

                case 42: {
                    if (localization_ == null)
                    {
                        localization_ = new global::Apollo.Localization.LocalizationEstimate();
                    }
                    input.ReadMessage(localization_);
                    break;
                }
                }
            }
        }
Example #6
0
        public void MergeFrom(pb::CodedInputStream input)
        {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
            input.ReadRawMessage(this);
    #else
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    PageUrl = input.ReadString();
                    break;
                }

                case 18: {
                    NextPageUrl = input.ReadString();
                    break;
                }

                case 26: {
                    metadata_.AddEntriesFrom(input, _map_metadata_codec);
                    break;
                }

                case 34: {
                    tracks_.AddEntriesFrom(input, _repeated_tracks_codec);
                    break;
                }

                case 40: {
                    Loading = input.ReadBool();
                    break;
                }
                }
            }
    #endif
        }
Example #7
0
    public void MergeFrom(pb::CodedInputStream input)
    {
  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
        input.ReadRawMessage(this);
  #else
        uint tag;
        while ((tag = input.ReadTag()) != 0)
        {
            switch (tag)
            {
            default:
                _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                break;

            case 8: {
                Time = input.ReadUInt64();
                break;
            }

            case 18: {
                Service = input.ReadString();
                break;
            }

            case 25: {
                Metricvalue = input.ReadDouble();
                break;
            }

            case 34: {
                Metricname = input.ReadString();
                break;
            }

            case 42: {
                attributes_.AddEntriesFrom(input, _map_attributes_codec);
                break;
            }
            }
        }
  #endif
    }
Example #8
0
        public void MergeFrom(pb::CodedInputStream input)
        {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
            input.ReadRawMessage(this);
    #else
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    AppName = input.ReadString();
                    break;
                }

                case 18: {
                    AppVersion = input.ReadString();
                    break;
                }

                case 26: {
                    AppChannel = input.ReadString();
                    break;
                }

                case 34: {
                    SdkVersion = input.ReadString();
                    break;
                }

                case 90: {
                    extensionInfo_.AddEntriesFrom(input, _map_extensionInfo_codec);
                    break;
                }
                }
            }
    #endif
        }
Example #9
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    Category = input.ReadString();
                    break;
                }

                case 18: {
                    Code = input.ReadString();
                    break;
                }

                case 26: {
                    CorrelationId = input.ReadString();
                    break;
                }

                case 32: {
                    Status = input.ReadInt32();
                    break;
                }

                case 42: {
                    Message = input.ReadString();
                    break;
                }

                case 50: {
                    Cause = input.ReadString();
                    break;
                }

                case 58: {
                    StackTrace = input.ReadString();
                    break;
                }

                case 66: {
                    details_.AddEntriesFrom(input, _map_details_codec);
                    break;
                }
                }
            }
        }
Example #10
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    Id = input.ReadString();
                    break;
                }

                case 18: {
                    FolderId = input.ReadString();
                    break;
                }

                case 26: {
                    if (createdAt_ == null)
                    {
                        CreatedAt = new global::Google.Protobuf.WellKnownTypes.Timestamp();
                    }
                    input.ReadMessage(CreatedAt);
                    break;
                }

                case 34: {
                    Name = input.ReadString();
                    break;
                }

                case 42: {
                    Description = input.ReadString();
                    break;
                }

                case 50: {
                    labels_.AddEntriesFrom(input, _map_labels_codec);
                    break;
                }

                case 58: {
                    DefaultSecurityGroupId = input.ReadString();
                    break;
                }
                }
            }
        }
Example #11
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (header_ == null)
                    {
                        header_ = new global::Apollo.Common.Header();
                    }
                    input.ReadMessage(header_);
                    break;
                }

                case 34: {
                    PassengerMsg = input.ReadString();
                    break;
                }

                case 41: {
                    SafetyModeTriggerTime = input.ReadDouble();
                    break;
                }

                case 48: {
                    RequireEmergencyStop = input.ReadBool();
                    break;
                }

                case 58: {
                    hmiModules_.AddEntriesFrom(input, _map_hmiModules_codec);
                    break;
                }

                case 66: {
                    components_.AddEntriesFrom(input, _map_components_codec);
                    break;
                }

                case 72: {
                    IsRealtimeInSimulation = input.ReadBool();
                    break;
                }
                }
            }
        }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 8: {
                    hookType_ = (global::Coprocess.HookType)input.ReadEnum();
                    break;
                }

                case 18: {
                    HookName = input.ReadString();
                    break;
                }

                case 26: {
                    if (request_ == null)
                    {
                        request_ = new global::Coprocess.MiniRequestObject();
                    }
                    input.ReadMessage(request_);
                    break;
                }

                case 34: {
                    if (session_ == null)
                    {
                        session_ = new global::Coprocess.SessionState();
                    }
                    input.ReadMessage(session_);
                    break;
                }

                case 42: {
                    metadata_.AddEntriesFrom(input, _map_metadata_codec);
                    break;
                }

                case 50: {
                    spec_.AddEntriesFrom(input, _map_spec_codec);
                    break;
                }
                }
            }
        }
Example #13
0
        public void MergeFrom(pb::CodedInputStream input)
        {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
            input.ReadRawMessage(this);
    #else
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    fields_.AddEntriesFrom(input, _map_fields_codec);
                    break;
                }
                }
            }
    #endif
        }
Example #14
0
 public void MergeFrom(pb::CodedInputStream input) {
   uint tag;
   while ((tag = input.ReadTag()) != 0) {
     switch(tag) {
       default:
         _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
         break;
       case 10: {
         input_.AddEntriesFrom(input, _map_input_codec);
         break;
       }
     }
   }
 }
Example #15
0
        public void MergeFrom(pb::CodedInputStream input)
        {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
            input.ReadRawMessage(this);
    #else
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    Name = input.ReadString();
                    break;
                }

                case 18: {
                    Address = input.ReadString();
                    break;
                }

                case 24: {
                    Port = input.ReadInt32();
                    break;
                }

                case 42: {
                    annotations_.AddEntriesFrom(input, _map_annotations_codec);
                    break;
                }
                }
            }
    #endif
        }
Example #16
0
        public void MergeFrom(pb::CodedInputStream input)
        {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
            input.ReadRawMessage(this);
    #else
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    StateId = input.ReadInt64();
                    break;
                }

                case 18: {
                    boardNames_.AddEntriesFrom(input, _map_boardNames_codec);
                    break;
                }

                case 26: {
                    playerNames_.AddEntriesFrom(input, _map_playerNames_codec);
                    break;
                }

                case 34: {
                    monsterNames_.AddEntriesFrom(input, _map_monsterNames_codec);
                    break;
                }
                }
            }
    #endif
        }
Example #17
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    Id = input.ReadInt32();
                    break;
                }

                case 18: {
                    Name = input.ReadString();
                    break;
                }

                case 26: {
                    metadata_.AddEntriesFrom(input, _map_metadata_codec);
                    break;
                }

                case 34: {
                    customEvents_.AddEntriesFrom(input, _repeated_customEvents_codec);
                    break;
                }

                case 42: {
                    lifecycleEvents_.AddEntriesFrom(input, _repeated_lifecycleEvents_codec);
                    break;
                }

                case 50: {
                    capturedPositions_.AddEntriesFrom(input, _repeated_capturedPositions_codec);
                    break;
                }

                case 58: {
                    capturedRotations_.AddEntriesFrom(input, _repeated_capturedRotations_codec);
                    break;
                }
                }
            }
        }
Example #18
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10:
                {
                    Account = input.ReadString();
                    break;
                }

                case 18:
                {
                    Password = input.ReadString();
                    break;
                }

                case 26:
                {
                    dict_.AddEntriesFrom(input, _map_dict_codec);
                    break;
                }

                case 34:
                {
                    adresses_.AddEntriesFrom(input, _repeated_adresses_codec);
                    break;
                }

                case 42:
                {
                    if (testSubProto_ == null)
                    {
                        testSubProto_ = new global::Com.Test.TestSubProto();
                    }
                    input.ReadMessage(testSubProto_);
                    break;
                }
                }
            }
        }
Example #19
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    authType_ = (global::V2Ray.Core.Proxy.Socks.AuthType)input.ReadEnum();
                    break;
                }

                case 18: {
                    accounts_.AddEntriesFrom(input, _map_accounts_codec);
                    break;
                }

                case 26: {
                    if (address_ == null)
                    {
                        address_ = new global::V2Ray.Core.Common.Net.IPOrDomain();
                    }
                    input.ReadMessage(address_);
                    break;
                }

                case 32: {
                    UdpEnabled = input.ReadBool();
                    break;
                }

                case 40: {
                    Timeout = input.ReadUInt32();
                    break;
                }

                case 48: {
                    UserLevel = input.ReadUInt32();
                    break;
                }
                }
            }
        }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    bool?value = _single_passThroughMode_codec.Read(input);
                    if (passThroughMode_ == null || value != false)
                    {
                        PassThroughMode = value;
                    }
                    break;
                }

                case 18: {
                    Endpoint = input.ReadString();
                    break;
                }

                case 26: {
                    if (cacheTime_ == null)
                    {
                        cacheTime_ = new global::Google.Protobuf.WellKnownTypes.Duration();
                    }
                    input.ReadMessage(cacheTime_);
                    break;
                }

                case 34: {
                    clusterMinHealthyPercentages_.AddEntriesFrom(input, _map_clusterMinHealthyPercentages_codec);
                    break;
                }

                case 42: {
                    headers_.AddEntriesFrom(input, _repeated_headers_codec);
                    break;
                }
                }
            }
        }
Example #21
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    stars_.AddEntriesFrom(input, _repeated_stars_codec);
                    break;
                }

                case 18:
                case 16: {
                    levels_.AddEntriesFrom(input, _repeated_levels_codec);
                    break;
                }

                case 26: {
                    names_.AddEntriesFrom(input, _map_names_codec);
                    break;
                }

                case 34: {
                    heroes_.AddEntriesFrom(input, _map_heroes_codec);
                    break;
                }

                case 42:
                case 40: {
                    listofHeros_.AddEntriesFrom(input, _repeated_listofHeros_codec);
                    break;
                }

                case 48: {
                    module_ = (global::UF.Config.Modules)input.ReadEnum();
                    break;
                }
                }
            }
        }
Example #22
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    if (identifier_ == null)
                    {
                        identifier_ = new global::Opencensus.Proto.Agent.Common.V1.ProcessIdentifier();
                    }
                    input.ReadMessage(identifier_);
                    break;
                }

                case 18: {
                    if (libraryInfo_ == null)
                    {
                        libraryInfo_ = new global::Opencensus.Proto.Agent.Common.V1.LibraryInfo();
                    }
                    input.ReadMessage(libraryInfo_);
                    break;
                }

                case 26: {
                    if (serviceInfo_ == null)
                    {
                        serviceInfo_ = new global::Opencensus.Proto.Agent.Common.V1.ServiceInfo();
                    }
                    input.ReadMessage(serviceInfo_);
                    break;
                }

                case 34: {
                    attributes_.AddEntriesFrom(input, _map_attributes_codec);
                    break;
                }
                }
            }
        }
Example #23
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    Name = input.ReadString();
                    break;
                }

                case 18: {
                    Image = input.ReadString();
                    break;
                }

                case 26: {
                    command_.AddEntriesFrom(input, _repeated_command_codec);
                    break;
                }

                case 34: {
                    env_.AddEntriesFrom(input, _map_env_codec);
                    break;
                }

                case 40: {
                    scalabilityModel_ = (global::Docker.AppSDK.ScalabilityModel)input.ReadEnum();
                    break;
                }

                case 50: {
                    ports_.AddEntriesFrom(input, _repeated_ports_codec);
                    break;
                }
                }
            }
        }
Example #24
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    DeviceId = input.ReadUInt32();
                    break;
                }

                case 16: {
                    ResourceId = input.ReadUInt32();
                    break;
                }

                case 26: {
                    Name = input.ReadString();
                    break;
                }

                case 72: {
                    TimestampPs = input.ReadUInt64();
                    break;
                }

                case 80: {
                    DurationPs = input.ReadUInt64();
                    break;
                }

                case 90: {
                    args_.AddEntriesFrom(input, _map_args_codec);
                    break;
                }
                }
            }
        }
Example #25
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 8: {
                    UserId = input.ReadSInt32();
                    break;
                }

                case 16: {
                    player_ = (global::PlayerPB)input.ReadEnum();
                    break;
                }

                case 24: {
                    Level = input.ReadSInt32();
                    break;
                }

                case 32: {
                    Exp = input.ReadSInt32();
                    break;
                }

                case 42: {
                    apparel_.AddEntriesFrom(input, _map_apparel_codec);
                    break;
                }

                case 50: {
                    voiceKeep_.AddEntriesFrom(input, _repeated_voiceKeep_codec);
                    break;
                }
                }
            }
        }
Example #26
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    TestNum = input.ReadInt32();
                    break;
                }

                case 21: {
                    TestFloat = input.ReadFloat();
                    break;
                }

                case 26: {
                    TestString = input.ReadString();
                    break;
                }

                case 32: {
                    TestBool = input.ReadBool();
                    break;
                }

                case 42: {
                    testList_.AddEntriesFrom(input, _repeated_testList_codec);
                    break;
                }

                case 50: {
                    testDic_.AddEntriesFrom(input, _map_testDic_codec);
                    break;
                }
                }
            }
        }
Example #27
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    Ver = input.ReadInt32();
                    break;
                }

                case 18: {
                    exceptions_.AddEntriesFrom(input, _repeated_exceptions_codec);
                    break;
                }

                case 24: {
                    severityLevel_ = (global::Microsoft.LocalForwarder.Library.Inputs.Contracts.SeverityLevel)input.ReadEnum();
                    break;
                }

                case 34: {
                    ProblemId = input.ReadString();
                    break;
                }

                case 42: {
                    properties_.AddEntriesFrom(input, _map_properties_codec);
                    break;
                }

                case 50: {
                    measurements_.AddEntriesFrom(input, _map_measurements_codec);
                    break;
                }
                }
            }
        }
Example #28
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 8: {
                    Gate = input.ReadSInt32();
                    break;
                }

                case 18: {
                    cosumes_.AddEntriesFrom(input, _map_cosumes_codec);
                    break;
                }

                case 26: {
                    SceneId = input.ReadString();
                    break;
                }

                case 32: {
                    Star = input.ReadSInt32();
                    break;
                }

                case 40: {
                    Evo = input.ReadSInt32();
                    break;
                }

                case 50: {
                    awards_.AddEntriesFrom(input, _repeated_awards_codec);
                    break;
                }
                }
            }
        }
Example #29
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    fields_.AddEntriesFrom(input, _map_fields_codec);
                    break;
                }
                }
            }
        }
Example #30
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    httpMethod_ = (global::Google.Cloud.Tasks.V2.HttpMethod)input.ReadEnum();
                    break;
                }

                case 18: {
                    if (appEngineRouting_ == null)
                    {
                        appEngineRouting_ = new global::Google.Cloud.Tasks.V2.AppEngineRouting();
                    }
                    input.ReadMessage(appEngineRouting_);
                    break;
                }

                case 26: {
                    RelativeUri = input.ReadString();
                    break;
                }

                case 34: {
                    headers_.AddEntriesFrom(input, _map_headers_codec);
                    break;
                }

                case 42: {
                    Body = input.ReadBytes();
                    break;
                }
                }
            }
        }