コード例 #1
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 16: {
                    HttpStatus = input.ReadUInt32();
                    break;
                }

                case 26: {
                    if (percentage_ == null)
                    {
                        Percentage = new global::Envoy.Type.FractionalPercent();
                    }
                    input.ReadMessage(Percentage);
                    break;
                }
                }
            }
        }
コード例 #2
0
        public void MergeFrom(FaultRateLimit other)
        {
            if (other == null)
            {
                return;
            }
            if (other.percentage_ != null)
            {
                if (percentage_ == null)
                {
                    Percentage = new global::Envoy.Type.FractionalPercent();
                }
                Percentage.MergeFrom(other.Percentage);
            }
            switch (other.LimitTypeCase)
            {
            case LimitTypeOneofCase.FixedLimit:
                if (FixedLimit == null)
                {
                    FixedLimit = new global::Envoy.Config.Filter.Fault.V3Alpha.FaultRateLimit.Types.FixedLimit();
                }
                FixedLimit.MergeFrom(other.FixedLimit);
                break;

            case LimitTypeOneofCase.HeaderLimit:
                if (HeaderLimit == null)
                {
                    HeaderLimit = new global::Envoy.Config.Filter.Fault.V3Alpha.FaultRateLimit.Types.HeaderLimit();
                }
                HeaderLimit.MergeFrom(other.HeaderLimit);
                break;
            }

            _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
        }
コード例 #3
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: {
                                    if (dropPercentage_ == null)
                                    {
                                        DropPercentage = new global::Envoy.Type.FractionalPercent();
                                    }
                                    input.ReadMessage(DropPercentage);
                                    break;
                                }
                                }
                            }
                        }
コード例 #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 8: {
                    Type = (global::Envoy.Config.Filter.Fault.V3Alpha.FaultDelay.Types.FaultDelayType)input.ReadEnum();
                    break;
                }

                case 26: {
                    global::Google.Protobuf.WellKnownTypes.Duration subBuilder = new global::Google.Protobuf.WellKnownTypes.Duration();
                    if (faultDelaySecifierCase_ == FaultDelaySecifierOneofCase.FixedDelay)
                    {
                        subBuilder.MergeFrom(FixedDelay);
                    }
                    input.ReadMessage(subBuilder);
                    FixedDelay = subBuilder;
                    break;
                }

                case 34: {
                    if (percentage_ == null)
                    {
                        Percentage = new global::Envoy.Type.FractionalPercent();
                    }
                    input.ReadMessage(Percentage);
                    break;
                }

                case 42: {
                    global::Envoy.Config.Filter.Fault.V3Alpha.FaultDelay.Types.HeaderDelay subBuilder = new global::Envoy.Config.Filter.Fault.V3Alpha.FaultDelay.Types.HeaderDelay();
                    if (faultDelaySecifierCase_ == FaultDelaySecifierOneofCase.HeaderDelay)
                    {
                        subBuilder.MergeFrom(HeaderDelay);
                    }
                    input.ReadMessage(subBuilder);
                    HeaderDelay = subBuilder;
                    break;
                }
                }
            }
        }
コード例 #5
0
 public void MergeFrom(DropOverload other) {
   if (other == null) {
     return;
   }
   if (other.Category.Length != 0) {
     Category = other.Category;
   }
   if (other.dropPercentage_ != null) {
     if (dropPercentage_ == null) {
       DropPercentage = new global::Envoy.Type.FractionalPercent();
     }
     DropPercentage.MergeFrom(other.DropPercentage);
   }
   _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
 }
コード例 #6
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: {
                    global::Envoy.Config.Filter.Fault.V3Alpha.FaultRateLimit.Types.FixedLimit subBuilder = new global::Envoy.Config.Filter.Fault.V3Alpha.FaultRateLimit.Types.FixedLimit();
                    if (limitTypeCase_ == LimitTypeOneofCase.FixedLimit)
                    {
                        subBuilder.MergeFrom(FixedLimit);
                    }
                    input.ReadMessage(subBuilder);
                    FixedLimit = subBuilder;
                    break;
                }

                case 18: {
                    if (percentage_ == null)
                    {
                        Percentage = new global::Envoy.Type.FractionalPercent();
                    }
                    input.ReadMessage(Percentage);
                    break;
                }

                case 26: {
                    global::Envoy.Config.Filter.Fault.V3Alpha.FaultRateLimit.Types.HeaderLimit subBuilder = new global::Envoy.Config.Filter.Fault.V3Alpha.FaultRateLimit.Types.HeaderLimit();
                    if (limitTypeCase_ == LimitTypeOneofCase.HeaderLimit)
                    {
                        subBuilder.MergeFrom(HeaderLimit);
                    }
                    input.ReadMessage(subBuilder);
                    HeaderLimit = subBuilder;
                    break;
                }
                }
            }
        }
コード例 #7
0
    public void MergeFrom(FaultAbort other) {
      if (other == null) {
        return;
      }
      if (other.percentage_ != null) {
        if (percentage_ == null) {
          Percentage = new global::Envoy.Type.FractionalPercent();
        }
        Percentage.MergeFrom(other.Percentage);
      }
      switch (other.ErrorTypeCase) {
        case ErrorTypeOneofCase.HttpStatus:
          HttpStatus = other.HttpStatus;
          break;
      }

      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
コード例 #8
0
        public void MergeFrom(FaultDelay other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Type != global::Envoy.Config.Filter.Fault.V3Alpha.FaultDelay.Types.FaultDelayType.Fixed)
            {
                Type = other.Type;
            }
            if (other.percentage_ != null)
            {
                if (percentage_ == null)
                {
                    Percentage = new global::Envoy.Type.FractionalPercent();
                }
                Percentage.MergeFrom(other.Percentage);
            }
            switch (other.FaultDelaySecifierCase)
            {
            case FaultDelaySecifierOneofCase.FixedDelay:
                if (FixedDelay == null)
                {
                    FixedDelay = new global::Google.Protobuf.WellKnownTypes.Duration();
                }
                FixedDelay.MergeFrom(other.FixedDelay);
                break;

            case FaultDelaySecifierOneofCase.HeaderDelay:
                if (HeaderDelay == null)
                {
                    HeaderDelay = new global::Envoy.Config.Filter.Fault.V3Alpha.FaultDelay.Types.HeaderDelay();
                }
                HeaderDelay.MergeFrom(other.HeaderDelay);
                break;
            }

            _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
        }