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 (delay_ == null)
                    {
                        Delay = new global::Envoy.Config.Filter.Fault.V2.FaultDelay();
                    }
                    input.ReadMessage(Delay);
                    break;
                }

                case 18: {
                    if (abort_ == null)
                    {
                        Abort = new global::Envoy.Config.Filter.Http.Fault.V2.FaultAbort();
                    }
                    input.ReadMessage(Abort);
                    break;
                }

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

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

                case 42: {
                    downstreamNodes_.AddEntriesFrom(input, _repeated_downstreamNodes_codec);
                    break;
                }

                case 50: {
                    uint?value = _single_maxActiveFaults_codec.Read(input);
                    if (maxActiveFaults_ == null || value != 0)
                    {
                        MaxActiveFaults = value;
                    }
                    break;
                }

                case 58: {
                    if (responseRateLimit_ == null)
                    {
                        ResponseRateLimit = new global::Envoy.Config.Filter.Fault.V2.FaultRateLimit();
                    }
                    input.ReadMessage(ResponseRateLimit);
                    break;
                }

                case 66: {
                    DelayPercentRuntime = input.ReadString();
                    break;
                }

                case 74: {
                    AbortPercentRuntime = input.ReadString();
                    break;
                }

                case 82: {
                    DelayDurationRuntime = input.ReadString();
                    break;
                }

                case 90: {
                    AbortHttpStatusRuntime = input.ReadString();
                    break;
                }

                case 98: {
                    MaxActiveFaultsRuntime = input.ReadString();
                    break;
                }

                case 106: {
                    ResponseRateLimitPercentRuntime = input.ReadString();
                    break;
                }
                }
            }
        }
 public void MergeFrom(HTTPFault other)
 {
     if (other == null)
     {
         return;
     }
     if (other.delay_ != null)
     {
         if (delay_ == null)
         {
             Delay = new global::Envoy.Config.Filter.Fault.V2.FaultDelay();
         }
         Delay.MergeFrom(other.Delay);
     }
     if (other.abort_ != null)
     {
         if (abort_ == null)
         {
             Abort = new global::Envoy.Config.Filter.Http.Fault.V2.FaultAbort();
         }
         Abort.MergeFrom(other.Abort);
     }
     if (other.UpstreamCluster.Length != 0)
     {
         UpstreamCluster = other.UpstreamCluster;
     }
     headers_.Add(other.headers_);
     downstreamNodes_.Add(other.downstreamNodes_);
     if (other.maxActiveFaults_ != null)
     {
         if (maxActiveFaults_ == null || other.MaxActiveFaults != 0)
         {
             MaxActiveFaults = other.MaxActiveFaults;
         }
     }
     if (other.responseRateLimit_ != null)
     {
         if (responseRateLimit_ == null)
         {
             ResponseRateLimit = new global::Envoy.Config.Filter.Fault.V2.FaultRateLimit();
         }
         ResponseRateLimit.MergeFrom(other.ResponseRateLimit);
     }
     if (other.DelayPercentRuntime.Length != 0)
     {
         DelayPercentRuntime = other.DelayPercentRuntime;
     }
     if (other.AbortPercentRuntime.Length != 0)
     {
         AbortPercentRuntime = other.AbortPercentRuntime;
     }
     if (other.DelayDurationRuntime.Length != 0)
     {
         DelayDurationRuntime = other.DelayDurationRuntime;
     }
     if (other.AbortHttpStatusRuntime.Length != 0)
     {
         AbortHttpStatusRuntime = other.AbortHttpStatusRuntime;
     }
     if (other.MaxActiveFaultsRuntime.Length != 0)
     {
         MaxActiveFaultsRuntime = other.MaxActiveFaultsRuntime;
     }
     if (other.ResponseRateLimitPercentRuntime.Length != 0)
     {
         ResponseRateLimitPercentRuntime = other.ResponseRateLimitPercentRuntime;
     }
     _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
 }