Source file src/github.com/openshift/api/route/v1/generated.pb.go

Documentation: github.com/openshift/api/route/v1

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: github.com/openshift/api/route/v1/generated.proto
     3  
     4  package v1
     5  
     6  import (
     7  	fmt "fmt"
     8  
     9  	io "io"
    10  
    11  	proto "github.com/gogo/protobuf/proto"
    12  
    13  	k8s_io_api_core_v1 "k8s.io/api/core/v1"
    14  	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    15  
    16  	math "math"
    17  	math_bits "math/bits"
    18  	reflect "reflect"
    19  	strings "strings"
    20  )
    21  
    22  // Reference imports to suppress errors if they are not otherwise used.
    23  var _ = proto.Marshal
    24  var _ = fmt.Errorf
    25  var _ = math.Inf
    26  
    27  // This is a compile-time assertion to ensure that this generated file
    28  // is compatible with the proto package it is being compiled against.
    29  // A compilation error at this line likely means your copy of the
    30  // proto package needs to be updated.
    31  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    32  
    33  func (m *Route) Reset()      { *m = Route{} }
    34  func (*Route) ProtoMessage() {}
    35  func (*Route) Descriptor() ([]byte, []int) {
    36  	return fileDescriptor_373b8fa7ff738721, []int{0}
    37  }
    38  func (m *Route) XXX_Unmarshal(b []byte) error {
    39  	return m.Unmarshal(b)
    40  }
    41  func (m *Route) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    42  	b = b[:cap(b)]
    43  	n, err := m.MarshalToSizedBuffer(b)
    44  	if err != nil {
    45  		return nil, err
    46  	}
    47  	return b[:n], nil
    48  }
    49  func (m *Route) XXX_Merge(src proto.Message) {
    50  	xxx_messageInfo_Route.Merge(m, src)
    51  }
    52  func (m *Route) XXX_Size() int {
    53  	return m.Size()
    54  }
    55  func (m *Route) XXX_DiscardUnknown() {
    56  	xxx_messageInfo_Route.DiscardUnknown(m)
    57  }
    58  
    59  var xxx_messageInfo_Route proto.InternalMessageInfo
    60  
    61  func (m *RouteIngress) Reset()      { *m = RouteIngress{} }
    62  func (*RouteIngress) ProtoMessage() {}
    63  func (*RouteIngress) Descriptor() ([]byte, []int) {
    64  	return fileDescriptor_373b8fa7ff738721, []int{1}
    65  }
    66  func (m *RouteIngress) XXX_Unmarshal(b []byte) error {
    67  	return m.Unmarshal(b)
    68  }
    69  func (m *RouteIngress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    70  	b = b[:cap(b)]
    71  	n, err := m.MarshalToSizedBuffer(b)
    72  	if err != nil {
    73  		return nil, err
    74  	}
    75  	return b[:n], nil
    76  }
    77  func (m *RouteIngress) XXX_Merge(src proto.Message) {
    78  	xxx_messageInfo_RouteIngress.Merge(m, src)
    79  }
    80  func (m *RouteIngress) XXX_Size() int {
    81  	return m.Size()
    82  }
    83  func (m *RouteIngress) XXX_DiscardUnknown() {
    84  	xxx_messageInfo_RouteIngress.DiscardUnknown(m)
    85  }
    86  
    87  var xxx_messageInfo_RouteIngress proto.InternalMessageInfo
    88  
    89  func (m *RouteIngressCondition) Reset()      { *m = RouteIngressCondition{} }
    90  func (*RouteIngressCondition) ProtoMessage() {}
    91  func (*RouteIngressCondition) Descriptor() ([]byte, []int) {
    92  	return fileDescriptor_373b8fa7ff738721, []int{2}
    93  }
    94  func (m *RouteIngressCondition) XXX_Unmarshal(b []byte) error {
    95  	return m.Unmarshal(b)
    96  }
    97  func (m *RouteIngressCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    98  	b = b[:cap(b)]
    99  	n, err := m.MarshalToSizedBuffer(b)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  	return b[:n], nil
   104  }
   105  func (m *RouteIngressCondition) XXX_Merge(src proto.Message) {
   106  	xxx_messageInfo_RouteIngressCondition.Merge(m, src)
   107  }
   108  func (m *RouteIngressCondition) XXX_Size() int {
   109  	return m.Size()
   110  }
   111  func (m *RouteIngressCondition) XXX_DiscardUnknown() {
   112  	xxx_messageInfo_RouteIngressCondition.DiscardUnknown(m)
   113  }
   114  
   115  var xxx_messageInfo_RouteIngressCondition proto.InternalMessageInfo
   116  
   117  func (m *RouteList) Reset()      { *m = RouteList{} }
   118  func (*RouteList) ProtoMessage() {}
   119  func (*RouteList) Descriptor() ([]byte, []int) {
   120  	return fileDescriptor_373b8fa7ff738721, []int{3}
   121  }
   122  func (m *RouteList) XXX_Unmarshal(b []byte) error {
   123  	return m.Unmarshal(b)
   124  }
   125  func (m *RouteList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   126  	b = b[:cap(b)]
   127  	n, err := m.MarshalToSizedBuffer(b)
   128  	if err != nil {
   129  		return nil, err
   130  	}
   131  	return b[:n], nil
   132  }
   133  func (m *RouteList) XXX_Merge(src proto.Message) {
   134  	xxx_messageInfo_RouteList.Merge(m, src)
   135  }
   136  func (m *RouteList) XXX_Size() int {
   137  	return m.Size()
   138  }
   139  func (m *RouteList) XXX_DiscardUnknown() {
   140  	xxx_messageInfo_RouteList.DiscardUnknown(m)
   141  }
   142  
   143  var xxx_messageInfo_RouteList proto.InternalMessageInfo
   144  
   145  func (m *RoutePort) Reset()      { *m = RoutePort{} }
   146  func (*RoutePort) ProtoMessage() {}
   147  func (*RoutePort) Descriptor() ([]byte, []int) {
   148  	return fileDescriptor_373b8fa7ff738721, []int{4}
   149  }
   150  func (m *RoutePort) XXX_Unmarshal(b []byte) error {
   151  	return m.Unmarshal(b)
   152  }
   153  func (m *RoutePort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   154  	b = b[:cap(b)]
   155  	n, err := m.MarshalToSizedBuffer(b)
   156  	if err != nil {
   157  		return nil, err
   158  	}
   159  	return b[:n], nil
   160  }
   161  func (m *RoutePort) XXX_Merge(src proto.Message) {
   162  	xxx_messageInfo_RoutePort.Merge(m, src)
   163  }
   164  func (m *RoutePort) XXX_Size() int {
   165  	return m.Size()
   166  }
   167  func (m *RoutePort) XXX_DiscardUnknown() {
   168  	xxx_messageInfo_RoutePort.DiscardUnknown(m)
   169  }
   170  
   171  var xxx_messageInfo_RoutePort proto.InternalMessageInfo
   172  
   173  func (m *RouteSpec) Reset()      { *m = RouteSpec{} }
   174  func (*RouteSpec) ProtoMessage() {}
   175  func (*RouteSpec) Descriptor() ([]byte, []int) {
   176  	return fileDescriptor_373b8fa7ff738721, []int{5}
   177  }
   178  func (m *RouteSpec) XXX_Unmarshal(b []byte) error {
   179  	return m.Unmarshal(b)
   180  }
   181  func (m *RouteSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   182  	b = b[:cap(b)]
   183  	n, err := m.MarshalToSizedBuffer(b)
   184  	if err != nil {
   185  		return nil, err
   186  	}
   187  	return b[:n], nil
   188  }
   189  func (m *RouteSpec) XXX_Merge(src proto.Message) {
   190  	xxx_messageInfo_RouteSpec.Merge(m, src)
   191  }
   192  func (m *RouteSpec) XXX_Size() int {
   193  	return m.Size()
   194  }
   195  func (m *RouteSpec) XXX_DiscardUnknown() {
   196  	xxx_messageInfo_RouteSpec.DiscardUnknown(m)
   197  }
   198  
   199  var xxx_messageInfo_RouteSpec proto.InternalMessageInfo
   200  
   201  func (m *RouteStatus) Reset()      { *m = RouteStatus{} }
   202  func (*RouteStatus) ProtoMessage() {}
   203  func (*RouteStatus) Descriptor() ([]byte, []int) {
   204  	return fileDescriptor_373b8fa7ff738721, []int{6}
   205  }
   206  func (m *RouteStatus) XXX_Unmarshal(b []byte) error {
   207  	return m.Unmarshal(b)
   208  }
   209  func (m *RouteStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   210  	b = b[:cap(b)]
   211  	n, err := m.MarshalToSizedBuffer(b)
   212  	if err != nil {
   213  		return nil, err
   214  	}
   215  	return b[:n], nil
   216  }
   217  func (m *RouteStatus) XXX_Merge(src proto.Message) {
   218  	xxx_messageInfo_RouteStatus.Merge(m, src)
   219  }
   220  func (m *RouteStatus) XXX_Size() int {
   221  	return m.Size()
   222  }
   223  func (m *RouteStatus) XXX_DiscardUnknown() {
   224  	xxx_messageInfo_RouteStatus.DiscardUnknown(m)
   225  }
   226  
   227  var xxx_messageInfo_RouteStatus proto.InternalMessageInfo
   228  
   229  func (m *RouteTargetReference) Reset()      { *m = RouteTargetReference{} }
   230  func (*RouteTargetReference) ProtoMessage() {}
   231  func (*RouteTargetReference) Descriptor() ([]byte, []int) {
   232  	return fileDescriptor_373b8fa7ff738721, []int{7}
   233  }
   234  func (m *RouteTargetReference) XXX_Unmarshal(b []byte) error {
   235  	return m.Unmarshal(b)
   236  }
   237  func (m *RouteTargetReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   238  	b = b[:cap(b)]
   239  	n, err := m.MarshalToSizedBuffer(b)
   240  	if err != nil {
   241  		return nil, err
   242  	}
   243  	return b[:n], nil
   244  }
   245  func (m *RouteTargetReference) XXX_Merge(src proto.Message) {
   246  	xxx_messageInfo_RouteTargetReference.Merge(m, src)
   247  }
   248  func (m *RouteTargetReference) XXX_Size() int {
   249  	return m.Size()
   250  }
   251  func (m *RouteTargetReference) XXX_DiscardUnknown() {
   252  	xxx_messageInfo_RouteTargetReference.DiscardUnknown(m)
   253  }
   254  
   255  var xxx_messageInfo_RouteTargetReference proto.InternalMessageInfo
   256  
   257  func (m *RouterShard) Reset()      { *m = RouterShard{} }
   258  func (*RouterShard) ProtoMessage() {}
   259  func (*RouterShard) Descriptor() ([]byte, []int) {
   260  	return fileDescriptor_373b8fa7ff738721, []int{8}
   261  }
   262  func (m *RouterShard) XXX_Unmarshal(b []byte) error {
   263  	return m.Unmarshal(b)
   264  }
   265  func (m *RouterShard) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   266  	b = b[:cap(b)]
   267  	n, err := m.MarshalToSizedBuffer(b)
   268  	if err != nil {
   269  		return nil, err
   270  	}
   271  	return b[:n], nil
   272  }
   273  func (m *RouterShard) XXX_Merge(src proto.Message) {
   274  	xxx_messageInfo_RouterShard.Merge(m, src)
   275  }
   276  func (m *RouterShard) XXX_Size() int {
   277  	return m.Size()
   278  }
   279  func (m *RouterShard) XXX_DiscardUnknown() {
   280  	xxx_messageInfo_RouterShard.DiscardUnknown(m)
   281  }
   282  
   283  var xxx_messageInfo_RouterShard proto.InternalMessageInfo
   284  
   285  func (m *TLSConfig) Reset()      { *m = TLSConfig{} }
   286  func (*TLSConfig) ProtoMessage() {}
   287  func (*TLSConfig) Descriptor() ([]byte, []int) {
   288  	return fileDescriptor_373b8fa7ff738721, []int{9}
   289  }
   290  func (m *TLSConfig) XXX_Unmarshal(b []byte) error {
   291  	return m.Unmarshal(b)
   292  }
   293  func (m *TLSConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   294  	b = b[:cap(b)]
   295  	n, err := m.MarshalToSizedBuffer(b)
   296  	if err != nil {
   297  		return nil, err
   298  	}
   299  	return b[:n], nil
   300  }
   301  func (m *TLSConfig) XXX_Merge(src proto.Message) {
   302  	xxx_messageInfo_TLSConfig.Merge(m, src)
   303  }
   304  func (m *TLSConfig) XXX_Size() int {
   305  	return m.Size()
   306  }
   307  func (m *TLSConfig) XXX_DiscardUnknown() {
   308  	xxx_messageInfo_TLSConfig.DiscardUnknown(m)
   309  }
   310  
   311  var xxx_messageInfo_TLSConfig proto.InternalMessageInfo
   312  
   313  func init() {
   314  	proto.RegisterType((*Route)(nil), "github.com.openshift.api.route.v1.Route")
   315  	proto.RegisterType((*RouteIngress)(nil), "github.com.openshift.api.route.v1.RouteIngress")
   316  	proto.RegisterType((*RouteIngressCondition)(nil), "github.com.openshift.api.route.v1.RouteIngressCondition")
   317  	proto.RegisterType((*RouteList)(nil), "github.com.openshift.api.route.v1.RouteList")
   318  	proto.RegisterType((*RoutePort)(nil), "github.com.openshift.api.route.v1.RoutePort")
   319  	proto.RegisterType((*RouteSpec)(nil), "github.com.openshift.api.route.v1.RouteSpec")
   320  	proto.RegisterType((*RouteStatus)(nil), "github.com.openshift.api.route.v1.RouteStatus")
   321  	proto.RegisterType((*RouteTargetReference)(nil), "github.com.openshift.api.route.v1.RouteTargetReference")
   322  	proto.RegisterType((*RouterShard)(nil), "github.com.openshift.api.route.v1.RouterShard")
   323  	proto.RegisterType((*TLSConfig)(nil), "github.com.openshift.api.route.v1.TLSConfig")
   324  }
   325  
   326  func init() {
   327  	proto.RegisterFile("github.com/openshift/api/route/v1/generated.proto", fileDescriptor_373b8fa7ff738721)
   328  }
   329  
   330  var fileDescriptor_373b8fa7ff738721 = []byte{
   331  	// 1168 bytes of a gzipped FileDescriptorProto
   332  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xcf, 0x6f, 0x1b, 0xc5,
   333  	0x17, 0xcf, 0xfa, 0x57, 0xe2, 0x71, 0xdb, 0xef, 0xb7, 0x03, 0xa5, 0x6e, 0xa4, 0xd8, 0xc9, 0x1e,
   334  	0x50, 0x8a, 0xca, 0x2e, 0x09, 0x05, 0x2a, 0x21, 0x0e, 0x75, 0x8a, 0x4a, 0x1a, 0x27, 0x8d, 0xc6,
   335  	0x16, 0x15, 0x55, 0x0f, 0x4c, 0x76, 0xc7, 0xeb, 0xc1, 0xf6, 0xec, 0x32, 0x33, 0x4e, 0xf1, 0x05,
   336  	0x55, 0xe2, 0x1f, 0x28, 0xff, 0x0d, 0x77, 0x2e, 0x39, 0xf6, 0xd8, 0x03, 0xb2, 0x88, 0x39, 0xf2,
   337  	0x1f, 0xe4, 0x84, 0x66, 0x76, 0xec, 0x5d, 0x3b, 0x4e, 0xe2, 0xc2, 0xcd, 0xfb, 0xde, 0xe7, 0xf3,
   338  	0x79, 0x6f, 0xde, 0x7b, 0xf3, 0x46, 0x06, 0x5b, 0x01, 0x95, 0xed, 0xfe, 0x91, 0xe3, 0x85, 0x3d,
   339  	0x37, 0x8c, 0x08, 0x13, 0x6d, 0xda, 0x92, 0x2e, 0x8e, 0xa8, 0xcb, 0xc3, 0xbe, 0x24, 0xee, 0xf1,
   340  	0x96, 0x1b, 0x10, 0x46, 0x38, 0x96, 0xc4, 0x77, 0x22, 0x1e, 0xca, 0x10, 0x6e, 0x24, 0x14, 0x67,
   341  	0x42, 0x71, 0x70, 0x44, 0x1d, 0x4d, 0x71, 0x8e, 0xb7, 0x56, 0x3f, 0x4e, 0xa9, 0x06, 0x61, 0x10,
   342  	0xba, 0x9a, 0x79, 0xd4, 0x6f, 0xe9, 0x2f, 0xfd, 0xa1, 0x7f, 0xc5, 0x8a, 0xab, 0x76, 0xe7, 0x81,
   343  	0x70, 0x68, 0xa8, 0xc3, 0x7a, 0x21, 0x9f, 0x17, 0x75, 0xf5, 0x7e, 0x82, 0xe9, 0x61, 0xaf, 0x4d,
   344  	0x19, 0xe1, 0x03, 0x37, 0xea, 0x04, 0xca, 0x20, 0xdc, 0x1e, 0x91, 0x78, 0x1e, 0xeb, 0xf3, 0x8b,
   345  	0x58, 0xbc, 0xcf, 0x24, 0xed, 0x11, 0x57, 0x78, 0x6d, 0xd2, 0xc3, 0xe7, 0x78, 0x9f, 0x5e, 0xc4,
   346  	0xeb, 0x4b, 0xda, 0x75, 0x29, 0x93, 0x42, 0xf2, 0x59, 0x92, 0xfd, 0x6b, 0x06, 0xe4, 0x91, 0x2a,
   347  	0x01, 0xfc, 0x1e, 0xac, 0xa8, 0x8c, 0x7c, 0x2c, 0x71, 0xd9, 0x5a, 0xb7, 0x36, 0x4b, 0xdb, 0x9f,
   348  	0x38, 0xb1, 0xa2, 0x93, 0x56, 0x74, 0xa2, 0x4e, 0xa0, 0x0c, 0xc2, 0x51, 0x68, 0xe7, 0x78, 0xcb,
   349  	0x79, 0x7a, 0xf4, 0x03, 0xf1, 0xe4, 0x3e, 0x91, 0xb8, 0x06, 0x4f, 0x86, 0xd5, 0xa5, 0xd1, 0xb0,
   350  	0x0a, 0x12, 0x1b, 0x9a, 0xa8, 0xc2, 0x03, 0x90, 0x13, 0x11, 0xf1, 0xca, 0x19, 0xad, 0x7e, 0xcf,
   351  	0xb9, 0xb2, 0x27, 0x8e, 0xce, 0xac, 0x11, 0x11, 0xaf, 0x76, 0xcd, 0x28, 0xe7, 0xd4, 0x17, 0xd2,
   352  	0x3a, 0xf0, 0x5b, 0x50, 0x10, 0x12, 0xcb, 0xbe, 0x28, 0x67, 0xb5, 0xa2, 0xb3, 0xb0, 0xa2, 0x66,
   353  	0xd5, 0x6e, 0x18, 0xcd, 0x42, 0xfc, 0x8d, 0x8c, 0x9a, 0xfd, 0x4b, 0x16, 0x5c, 0xd3, 0xb8, 0x5d,
   354  	0x16, 0x70, 0x22, 0x04, 0x5c, 0x07, 0xb9, 0x76, 0x28, 0xa4, 0x2e, 0x4b, 0x31, 0x49, 0xe5, 0x9b,
   355  	0x50, 0x48, 0xa4, 0x3d, 0x70, 0x1b, 0x00, 0x1d, 0x82, 0x1f, 0xe0, 0x1e, 0xd1, 0x07, 0x2c, 0x26,
   356  	0xc5, 0x40, 0x13, 0x0f, 0x4a, 0xa1, 0x60, 0x17, 0x00, 0x2f, 0x64, 0x3e, 0x95, 0x34, 0x64, 0xea,
   357  	0x08, 0xd9, 0xcd, 0xd2, 0xf6, 0x83, 0x45, 0x8f, 0x60, 0x52, 0xdb, 0x19, 0x0b, 0x24, 0xd1, 0x26,
   358  	0x26, 0x81, 0x52, 0xfa, 0xb0, 0x09, 0x6e, 0xbc, 0xa4, 0x5d, 0xdf, 0xc3, 0xdc, 0x3f, 0x0c, 0xbb,
   359  	0xd4, 0x1b, 0x94, 0x73, 0x3a, 0xcb, 0x7b, 0x86, 0x77, 0xe3, 0xd9, 0x94, 0xf7, 0x6c, 0x58, 0x85,
   360  	0xd3, 0x96, 0xe6, 0x20, 0x22, 0x68, 0x46, 0x03, 0x7e, 0x07, 0x6e, 0xc7, 0x27, 0xda, 0xc1, 0x2c,
   361  	0x64, 0xd4, 0xc3, 0x5d, 0x55, 0x14, 0xa6, 0x8a, 0x90, 0xd7, 0xf2, 0x55, 0x23, 0x7f, 0x1b, 0xcd,
   362  	0x87, 0xa1, 0x8b, 0xf8, 0xf6, 0xdf, 0x19, 0x70, 0x6b, 0xee, 0x51, 0xe1, 0x57, 0x20, 0x27, 0x07,
   363  	0x11, 0x31, 0xed, 0xb8, 0x3b, 0x6e, 0x87, 0x4a, 0xf0, 0x6c, 0x58, 0xbd, 0x33, 0x97, 0xa4, 0xb3,
   364  	0xd7, 0x34, 0x58, 0x9f, 0x8c, 0x4d, 0xdc, 0xa7, 0xfb, 0xd3, 0x63, 0x70, 0x36, 0xac, 0xce, 0xb9,
   365  	0xdb, 0xce, 0x44, 0x69, 0x7a, 0x58, 0xe0, 0x87, 0xa0, 0xc0, 0x09, 0x16, 0x21, 0xd3, 0x43, 0x58,
   366  	0x4c, 0x86, 0x0a, 0x69, 0x2b, 0x32, 0x5e, 0x78, 0x17, 0x2c, 0xf7, 0x88, 0x10, 0x38, 0x20, 0xa6,
   367  	0xf0, 0xff, 0x33, 0xc0, 0xe5, 0xfd, 0xd8, 0x8c, 0xc6, 0x7e, 0xc8, 0x01, 0xec, 0x62, 0x21, 0x9b,
   368  	0x1c, 0x33, 0x11, 0x27, 0x4f, 0x4d, 0x3d, 0x4b, 0xdb, 0x1f, 0x2d, 0x76, 0x27, 0x15, 0xa3, 0xf6,
   369  	0xc1, 0x68, 0x58, 0x85, 0xf5, 0x73, 0x4a, 0x68, 0x8e, 0xba, 0xfd, 0x9b, 0x05, 0x8a, 0xba, 0x70,
   370  	0x75, 0x2a, 0x24, 0x7c, 0x71, 0x6e, 0x17, 0x38, 0x8b, 0xc5, 0x55, 0x6c, 0xbd, 0x09, 0xfe, 0x6f,
   371  	0x4e, 0xb7, 0x32, 0xb6, 0xa4, 0xf6, 0xc0, 0x3e, 0xc8, 0x53, 0x49, 0x7a, 0xaa, 0xfe, 0x6a, 0xe6,
   372  	0x37, 0x17, 0x9d, 0xf9, 0xda, 0x75, 0x23, 0x9a, 0xdf, 0x55, 0x74, 0x14, 0xab, 0xd8, 0x3f, 0x9a,
   373  	0xcc, 0x0f, 0x43, 0x2e, 0xa1, 0x0f, 0x80, 0xc4, 0x3c, 0x20, 0x52, 0x7d, 0x5d, 0xb9, 0xc7, 0xd4,
   374  	0x66, 0x74, 0xe2, 0xcd, 0xe8, 0xec, 0x32, 0xf9, 0x94, 0x37, 0x24, 0xa7, 0x2c, 0x48, 0x2e, 0x53,
   375  	0x73, 0xa2, 0x85, 0x52, 0xba, 0xf6, 0xef, 0x39, 0x13, 0x53, 0x6d, 0xa3, 0x05, 0xd6, 0x83, 0x0b,
   376  	0x8a, 0xa2, 0x7f, 0xe4, 0x87, 0x3d, 0x4c, 0x59, 0x79, 0x45, 0xc3, 0x6e, 0x1a, 0x58, 0xb1, 0x31,
   377  	0x76, 0xa0, 0x04, 0xa3, 0x24, 0x23, 0x2c, 0xdb, 0x66, 0x42, 0x27, 0x92, 0x87, 0x58, 0xb6, 0x91,
   378  	0xf6, 0xc0, 0x06, 0xc8, 0xc8, 0xd0, 0x2c, 0xbe, 0x2f, 0x16, 0xad, 0x60, 0x7c, 0x1c, 0x44, 0x5a,
   379  	0x84, 0x13, 0xe6, 0x91, 0x1a, 0x30, 0xc2, 0x99, 0x66, 0x88, 0x32, 0x32, 0x84, 0xaf, 0x2c, 0x70,
   380  	0x13, 0x77, 0x25, 0xe1, 0x0c, 0x4b, 0x52, 0xc3, 0x5e, 0x87, 0x30, 0x5f, 0x94, 0x73, 0xba, 0x4d,
   381  	0xff, 0x3a, 0xc8, 0x1d, 0x13, 0xe4, 0xe6, 0xc3, 0x59, 0x65, 0x74, 0x3e, 0x18, 0x7c, 0x02, 0x72,
   382  	0x91, 0x6a, 0x5d, 0xfe, 0xdd, 0x1e, 0x09, 0xd5, 0x96, 0xda, 0x8a, 0xae, 0x91, 0x6a, 0x96, 0xd6,
   383  	0x80, 0x8f, 0x41, 0x56, 0x76, 0x45, 0xb9, 0xb0, 0xb0, 0x54, 0xb3, 0xde, 0xd8, 0x09, 0x59, 0x8b,
   384  	0x06, 0xb5, 0xe5, 0xd1, 0xb0, 0x9a, 0x6d, 0xd6, 0x1b, 0x48, 0x29, 0xcc, 0x59, 0x9e, 0xcb, 0xff,
   385  	0x7d, 0x79, 0xda, 0x14, 0x94, 0x52, 0xcf, 0x11, 0x7c, 0x0e, 0x96, 0x69, 0xbc, 0xb5, 0xca, 0x96,
   386  	0xae, 0xb8, 0xfb, 0x8e, 0x8f, 0x41, 0xb2, 0x52, 0x8c, 0x01, 0x8d, 0x05, 0xed, 0x9f, 0xc1, 0xfb,
   387  	0xf3, 0x7a, 0xa3, 0xe6, 0xac, 0x43, 0x99, 0x3f, 0x3b, 0xba, 0x7b, 0x94, 0xf9, 0x48, 0x7b, 0x14,
   388  	0x82, 0x25, 0x6f, 0xda, 0x04, 0xa1, 0x5f, 0x33, 0xed, 0x81, 0x36, 0x28, 0xbc, 0x24, 0x34, 0x68,
   389  	0x4b, 0x3d, 0x8d, 0xf9, 0x1a, 0x50, 0xdb, 0xef, 0x99, 0xb6, 0x20, 0xe3, 0xb1, 0x43, 0x73, 0x54,
   390  	0xde, 0x68, 0x63, 0xee, 0xeb, 0xfb, 0xa0, 0x7e, 0xe8, 0xd7, 0xd2, 0x9a, 0xb9, 0x0f, 0x63, 0x07,
   391  	0x4a, 0x30, 0x8a, 0xe0, 0x33, 0xd1, 0xe8, 0xb7, 0x5a, 0xf4, 0x27, 0x93, 0xca, 0x84, 0xf0, 0xe8,
   392  	0xa0, 0x11, 0x3b, 0x50, 0x82, 0xb1, 0xff, 0xc8, 0x82, 0xe2, 0xa4, 0x9b, 0x70, 0x0f, 0x94, 0x24,
   393  	0xe1, 0x3d, 0xca, 0xb0, 0x5a, 0x78, 0x33, 0x0f, 0x47, 0xa9, 0x99, 0xb8, 0x54, 0xe7, 0x9a, 0xf5,
   394  	0x46, 0xca, 0xa2, 0x3b, 0x97, 0x66, 0xc3, 0xcf, 0x40, 0xc9, 0x23, 0x5c, 0xd2, 0x16, 0xf5, 0xb0,
   395  	0x1c, 0x17, 0xe6, 0xbd, 0xb1, 0xd8, 0x4e, 0xe2, 0x42, 0x69, 0x1c, 0x5c, 0x03, 0xd9, 0x0e, 0x19,
   396  	0x98, 0x57, 0xa2, 0x64, 0xe0, 0xd9, 0x3d, 0x32, 0x40, 0xca, 0x0e, 0xbf, 0x04, 0xd7, 0x3d, 0x9c,
   397  	0x22, 0x9b, 0x57, 0xe2, 0x96, 0x01, 0x5e, 0xdf, 0x79, 0x98, 0x56, 0x9e, 0xc6, 0xc2, 0x17, 0xa0,
   398  	0xec, 0x13, 0x21, 0x4d, 0x86, 0x53, 0x50, 0xf3, 0x0e, 0xaf, 0x1b, 0x9d, 0xf2, 0xa3, 0x0b, 0x70,
   399  	0xe8, 0x42, 0x05, 0xf8, 0xda, 0x02, 0x6b, 0x94, 0x09, 0xe2, 0xf5, 0x39, 0xf9, 0xda, 0x0f, 0x48,
   400  	0xaa, 0x3a, 0xe6, 0x36, 0x14, 0x74, 0x8c, 0x27, 0x26, 0xc6, 0xda, 0xee, 0x65, 0xe0, 0xb3, 0x61,
   401  	0x75, 0xe3, 0x52, 0x80, 0xae, 0xf8, 0xe5, 0x01, 0x6b, 0x8f, 0x4f, 0x4e, 0x2b, 0x4b, 0x6f, 0x4e,
   402  	0x2b, 0x4b, 0x6f, 0x4f, 0x2b, 0x4b, 0xaf, 0x46, 0x15, 0xeb, 0x64, 0x54, 0xb1, 0xde, 0x8c, 0x2a,
   403  	0xd6, 0xdb, 0x51, 0xc5, 0xfa, 0x73, 0x54, 0xb1, 0x5e, 0xff, 0x55, 0x59, 0x7a, 0xbe, 0x71, 0xe5,
   404  	0x1f, 0x85, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x2a, 0x8e, 0xb3, 0x95, 0x4c, 0x0c, 0x00, 0x00,
   405  }
   406  
   407  func (m *Route) Marshal() (dAtA []byte, err error) {
   408  	size := m.Size()
   409  	dAtA = make([]byte, size)
   410  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   411  	if err != nil {
   412  		return nil, err
   413  	}
   414  	return dAtA[:n], nil
   415  }
   416  
   417  func (m *Route) MarshalTo(dAtA []byte) (int, error) {
   418  	size := m.Size()
   419  	return m.MarshalToSizedBuffer(dAtA[:size])
   420  }
   421  
   422  func (m *Route) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   423  	i := len(dAtA)
   424  	_ = i
   425  	var l int
   426  	_ = l
   427  	{
   428  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
   429  		if err != nil {
   430  			return 0, err
   431  		}
   432  		i -= size
   433  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   434  	}
   435  	i--
   436  	dAtA[i] = 0x1a
   437  	{
   438  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
   439  		if err != nil {
   440  			return 0, err
   441  		}
   442  		i -= size
   443  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   444  	}
   445  	i--
   446  	dAtA[i] = 0x12
   447  	{
   448  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   449  		if err != nil {
   450  			return 0, err
   451  		}
   452  		i -= size
   453  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   454  	}
   455  	i--
   456  	dAtA[i] = 0xa
   457  	return len(dAtA) - i, nil
   458  }
   459  
   460  func (m *RouteIngress) Marshal() (dAtA []byte, err error) {
   461  	size := m.Size()
   462  	dAtA = make([]byte, size)
   463  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   464  	if err != nil {
   465  		return nil, err
   466  	}
   467  	return dAtA[:n], nil
   468  }
   469  
   470  func (m *RouteIngress) MarshalTo(dAtA []byte) (int, error) {
   471  	size := m.Size()
   472  	return m.MarshalToSizedBuffer(dAtA[:size])
   473  }
   474  
   475  func (m *RouteIngress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   476  	i := len(dAtA)
   477  	_ = i
   478  	var l int
   479  	_ = l
   480  	i -= len(m.RouterCanonicalHostname)
   481  	copy(dAtA[i:], m.RouterCanonicalHostname)
   482  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RouterCanonicalHostname)))
   483  	i--
   484  	dAtA[i] = 0x2a
   485  	i -= len(m.WildcardPolicy)
   486  	copy(dAtA[i:], m.WildcardPolicy)
   487  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.WildcardPolicy)))
   488  	i--
   489  	dAtA[i] = 0x22
   490  	if len(m.Conditions) > 0 {
   491  		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
   492  			{
   493  				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   494  				if err != nil {
   495  					return 0, err
   496  				}
   497  				i -= size
   498  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   499  			}
   500  			i--
   501  			dAtA[i] = 0x1a
   502  		}
   503  	}
   504  	i -= len(m.RouterName)
   505  	copy(dAtA[i:], m.RouterName)
   506  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.RouterName)))
   507  	i--
   508  	dAtA[i] = 0x12
   509  	i -= len(m.Host)
   510  	copy(dAtA[i:], m.Host)
   511  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host)))
   512  	i--
   513  	dAtA[i] = 0xa
   514  	return len(dAtA) - i, nil
   515  }
   516  
   517  func (m *RouteIngressCondition) Marshal() (dAtA []byte, err error) {
   518  	size := m.Size()
   519  	dAtA = make([]byte, size)
   520  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   521  	if err != nil {
   522  		return nil, err
   523  	}
   524  	return dAtA[:n], nil
   525  }
   526  
   527  func (m *RouteIngressCondition) MarshalTo(dAtA []byte) (int, error) {
   528  	size := m.Size()
   529  	return m.MarshalToSizedBuffer(dAtA[:size])
   530  }
   531  
   532  func (m *RouteIngressCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   533  	i := len(dAtA)
   534  	_ = i
   535  	var l int
   536  	_ = l
   537  	if m.LastTransitionTime != nil {
   538  		{
   539  			size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
   540  			if err != nil {
   541  				return 0, err
   542  			}
   543  			i -= size
   544  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   545  		}
   546  		i--
   547  		dAtA[i] = 0x2a
   548  	}
   549  	i -= len(m.Message)
   550  	copy(dAtA[i:], m.Message)
   551  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
   552  	i--
   553  	dAtA[i] = 0x22
   554  	i -= len(m.Reason)
   555  	copy(dAtA[i:], m.Reason)
   556  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
   557  	i--
   558  	dAtA[i] = 0x1a
   559  	i -= len(m.Status)
   560  	copy(dAtA[i:], m.Status)
   561  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
   562  	i--
   563  	dAtA[i] = 0x12
   564  	i -= len(m.Type)
   565  	copy(dAtA[i:], m.Type)
   566  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
   567  	i--
   568  	dAtA[i] = 0xa
   569  	return len(dAtA) - i, nil
   570  }
   571  
   572  func (m *RouteList) Marshal() (dAtA []byte, err error) {
   573  	size := m.Size()
   574  	dAtA = make([]byte, size)
   575  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   576  	if err != nil {
   577  		return nil, err
   578  	}
   579  	return dAtA[:n], nil
   580  }
   581  
   582  func (m *RouteList) MarshalTo(dAtA []byte) (int, error) {
   583  	size := m.Size()
   584  	return m.MarshalToSizedBuffer(dAtA[:size])
   585  }
   586  
   587  func (m *RouteList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   588  	i := len(dAtA)
   589  	_ = i
   590  	var l int
   591  	_ = l
   592  	if len(m.Items) > 0 {
   593  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   594  			{
   595  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   596  				if err != nil {
   597  					return 0, err
   598  				}
   599  				i -= size
   600  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   601  			}
   602  			i--
   603  			dAtA[i] = 0x12
   604  		}
   605  	}
   606  	{
   607  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   608  		if err != nil {
   609  			return 0, err
   610  		}
   611  		i -= size
   612  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   613  	}
   614  	i--
   615  	dAtA[i] = 0xa
   616  	return len(dAtA) - i, nil
   617  }
   618  
   619  func (m *RoutePort) Marshal() (dAtA []byte, err error) {
   620  	size := m.Size()
   621  	dAtA = make([]byte, size)
   622  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   623  	if err != nil {
   624  		return nil, err
   625  	}
   626  	return dAtA[:n], nil
   627  }
   628  
   629  func (m *RoutePort) MarshalTo(dAtA []byte) (int, error) {
   630  	size := m.Size()
   631  	return m.MarshalToSizedBuffer(dAtA[:size])
   632  }
   633  
   634  func (m *RoutePort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   635  	i := len(dAtA)
   636  	_ = i
   637  	var l int
   638  	_ = l
   639  	{
   640  		size, err := m.TargetPort.MarshalToSizedBuffer(dAtA[:i])
   641  		if err != nil {
   642  			return 0, err
   643  		}
   644  		i -= size
   645  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   646  	}
   647  	i--
   648  	dAtA[i] = 0xa
   649  	return len(dAtA) - i, nil
   650  }
   651  
   652  func (m *RouteSpec) Marshal() (dAtA []byte, err error) {
   653  	size := m.Size()
   654  	dAtA = make([]byte, size)
   655  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   656  	if err != nil {
   657  		return nil, err
   658  	}
   659  	return dAtA[:n], nil
   660  }
   661  
   662  func (m *RouteSpec) MarshalTo(dAtA []byte) (int, error) {
   663  	size := m.Size()
   664  	return m.MarshalToSizedBuffer(dAtA[:size])
   665  }
   666  
   667  func (m *RouteSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   668  	i := len(dAtA)
   669  	_ = i
   670  	var l int
   671  	_ = l
   672  	i -= len(m.Subdomain)
   673  	copy(dAtA[i:], m.Subdomain)
   674  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Subdomain)))
   675  	i--
   676  	dAtA[i] = 0x42
   677  	i -= len(m.WildcardPolicy)
   678  	copy(dAtA[i:], m.WildcardPolicy)
   679  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.WildcardPolicy)))
   680  	i--
   681  	dAtA[i] = 0x3a
   682  	if m.TLS != nil {
   683  		{
   684  			size, err := m.TLS.MarshalToSizedBuffer(dAtA[:i])
   685  			if err != nil {
   686  				return 0, err
   687  			}
   688  			i -= size
   689  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   690  		}
   691  		i--
   692  		dAtA[i] = 0x32
   693  	}
   694  	if m.Port != nil {
   695  		{
   696  			size, err := m.Port.MarshalToSizedBuffer(dAtA[:i])
   697  			if err != nil {
   698  				return 0, err
   699  			}
   700  			i -= size
   701  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   702  		}
   703  		i--
   704  		dAtA[i] = 0x2a
   705  	}
   706  	if len(m.AlternateBackends) > 0 {
   707  		for iNdEx := len(m.AlternateBackends) - 1; iNdEx >= 0; iNdEx-- {
   708  			{
   709  				size, err := m.AlternateBackends[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   710  				if err != nil {
   711  					return 0, err
   712  				}
   713  				i -= size
   714  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   715  			}
   716  			i--
   717  			dAtA[i] = 0x22
   718  		}
   719  	}
   720  	{
   721  		size, err := m.To.MarshalToSizedBuffer(dAtA[:i])
   722  		if err != nil {
   723  			return 0, err
   724  		}
   725  		i -= size
   726  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   727  	}
   728  	i--
   729  	dAtA[i] = 0x1a
   730  	i -= len(m.Path)
   731  	copy(dAtA[i:], m.Path)
   732  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
   733  	i--
   734  	dAtA[i] = 0x12
   735  	i -= len(m.Host)
   736  	copy(dAtA[i:], m.Host)
   737  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host)))
   738  	i--
   739  	dAtA[i] = 0xa
   740  	return len(dAtA) - i, nil
   741  }
   742  
   743  func (m *RouteStatus) Marshal() (dAtA []byte, err error) {
   744  	size := m.Size()
   745  	dAtA = make([]byte, size)
   746  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   747  	if err != nil {
   748  		return nil, err
   749  	}
   750  	return dAtA[:n], nil
   751  }
   752  
   753  func (m *RouteStatus) MarshalTo(dAtA []byte) (int, error) {
   754  	size := m.Size()
   755  	return m.MarshalToSizedBuffer(dAtA[:size])
   756  }
   757  
   758  func (m *RouteStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   759  	i := len(dAtA)
   760  	_ = i
   761  	var l int
   762  	_ = l
   763  	if len(m.Ingress) > 0 {
   764  		for iNdEx := len(m.Ingress) - 1; iNdEx >= 0; iNdEx-- {
   765  			{
   766  				size, err := m.Ingress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   767  				if err != nil {
   768  					return 0, err
   769  				}
   770  				i -= size
   771  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   772  			}
   773  			i--
   774  			dAtA[i] = 0xa
   775  		}
   776  	}
   777  	return len(dAtA) - i, nil
   778  }
   779  
   780  func (m *RouteTargetReference) Marshal() (dAtA []byte, err error) {
   781  	size := m.Size()
   782  	dAtA = make([]byte, size)
   783  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   784  	if err != nil {
   785  		return nil, err
   786  	}
   787  	return dAtA[:n], nil
   788  }
   789  
   790  func (m *RouteTargetReference) MarshalTo(dAtA []byte) (int, error) {
   791  	size := m.Size()
   792  	return m.MarshalToSizedBuffer(dAtA[:size])
   793  }
   794  
   795  func (m *RouteTargetReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   796  	i := len(dAtA)
   797  	_ = i
   798  	var l int
   799  	_ = l
   800  	if m.Weight != nil {
   801  		i = encodeVarintGenerated(dAtA, i, uint64(*m.Weight))
   802  		i--
   803  		dAtA[i] = 0x18
   804  	}
   805  	i -= len(m.Name)
   806  	copy(dAtA[i:], m.Name)
   807  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
   808  	i--
   809  	dAtA[i] = 0x12
   810  	i -= len(m.Kind)
   811  	copy(dAtA[i:], m.Kind)
   812  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
   813  	i--
   814  	dAtA[i] = 0xa
   815  	return len(dAtA) - i, nil
   816  }
   817  
   818  func (m *RouterShard) Marshal() (dAtA []byte, err error) {
   819  	size := m.Size()
   820  	dAtA = make([]byte, size)
   821  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   822  	if err != nil {
   823  		return nil, err
   824  	}
   825  	return dAtA[:n], nil
   826  }
   827  
   828  func (m *RouterShard) MarshalTo(dAtA []byte) (int, error) {
   829  	size := m.Size()
   830  	return m.MarshalToSizedBuffer(dAtA[:size])
   831  }
   832  
   833  func (m *RouterShard) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   834  	i := len(dAtA)
   835  	_ = i
   836  	var l int
   837  	_ = l
   838  	i -= len(m.DNSSuffix)
   839  	copy(dAtA[i:], m.DNSSuffix)
   840  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.DNSSuffix)))
   841  	i--
   842  	dAtA[i] = 0x12
   843  	i -= len(m.ShardName)
   844  	copy(dAtA[i:], m.ShardName)
   845  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ShardName)))
   846  	i--
   847  	dAtA[i] = 0xa
   848  	return len(dAtA) - i, nil
   849  }
   850  
   851  func (m *TLSConfig) Marshal() (dAtA []byte, err error) {
   852  	size := m.Size()
   853  	dAtA = make([]byte, size)
   854  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   855  	if err != nil {
   856  		return nil, err
   857  	}
   858  	return dAtA[:n], nil
   859  }
   860  
   861  func (m *TLSConfig) MarshalTo(dAtA []byte) (int, error) {
   862  	size := m.Size()
   863  	return m.MarshalToSizedBuffer(dAtA[:size])
   864  }
   865  
   866  func (m *TLSConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   867  	i := len(dAtA)
   868  	_ = i
   869  	var l int
   870  	_ = l
   871  	i -= len(m.InsecureEdgeTerminationPolicy)
   872  	copy(dAtA[i:], m.InsecureEdgeTerminationPolicy)
   873  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.InsecureEdgeTerminationPolicy)))
   874  	i--
   875  	dAtA[i] = 0x32
   876  	i -= len(m.DestinationCACertificate)
   877  	copy(dAtA[i:], m.DestinationCACertificate)
   878  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.DestinationCACertificate)))
   879  	i--
   880  	dAtA[i] = 0x2a
   881  	i -= len(m.CACertificate)
   882  	copy(dAtA[i:], m.CACertificate)
   883  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CACertificate)))
   884  	i--
   885  	dAtA[i] = 0x22
   886  	i -= len(m.Key)
   887  	copy(dAtA[i:], m.Key)
   888  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
   889  	i--
   890  	dAtA[i] = 0x1a
   891  	i -= len(m.Certificate)
   892  	copy(dAtA[i:], m.Certificate)
   893  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Certificate)))
   894  	i--
   895  	dAtA[i] = 0x12
   896  	i -= len(m.Termination)
   897  	copy(dAtA[i:], m.Termination)
   898  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Termination)))
   899  	i--
   900  	dAtA[i] = 0xa
   901  	return len(dAtA) - i, nil
   902  }
   903  
   904  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
   905  	offset -= sovGenerated(v)
   906  	base := offset
   907  	for v >= 1<<7 {
   908  		dAtA[offset] = uint8(v&0x7f | 0x80)
   909  		v >>= 7
   910  		offset++
   911  	}
   912  	dAtA[offset] = uint8(v)
   913  	return base
   914  }
   915  func (m *Route) Size() (n int) {
   916  	if m == nil {
   917  		return 0
   918  	}
   919  	var l int
   920  	_ = l
   921  	l = m.ObjectMeta.Size()
   922  	n += 1 + l + sovGenerated(uint64(l))
   923  	l = m.Spec.Size()
   924  	n += 1 + l + sovGenerated(uint64(l))
   925  	l = m.Status.Size()
   926  	n += 1 + l + sovGenerated(uint64(l))
   927  	return n
   928  }
   929  
   930  func (m *RouteIngress) Size() (n int) {
   931  	if m == nil {
   932  		return 0
   933  	}
   934  	var l int
   935  	_ = l
   936  	l = len(m.Host)
   937  	n += 1 + l + sovGenerated(uint64(l))
   938  	l = len(m.RouterName)
   939  	n += 1 + l + sovGenerated(uint64(l))
   940  	if len(m.Conditions) > 0 {
   941  		for _, e := range m.Conditions {
   942  			l = e.Size()
   943  			n += 1 + l + sovGenerated(uint64(l))
   944  		}
   945  	}
   946  	l = len(m.WildcardPolicy)
   947  	n += 1 + l + sovGenerated(uint64(l))
   948  	l = len(m.RouterCanonicalHostname)
   949  	n += 1 + l + sovGenerated(uint64(l))
   950  	return n
   951  }
   952  
   953  func (m *RouteIngressCondition) Size() (n int) {
   954  	if m == nil {
   955  		return 0
   956  	}
   957  	var l int
   958  	_ = l
   959  	l = len(m.Type)
   960  	n += 1 + l + sovGenerated(uint64(l))
   961  	l = len(m.Status)
   962  	n += 1 + l + sovGenerated(uint64(l))
   963  	l = len(m.Reason)
   964  	n += 1 + l + sovGenerated(uint64(l))
   965  	l = len(m.Message)
   966  	n += 1 + l + sovGenerated(uint64(l))
   967  	if m.LastTransitionTime != nil {
   968  		l = m.LastTransitionTime.Size()
   969  		n += 1 + l + sovGenerated(uint64(l))
   970  	}
   971  	return n
   972  }
   973  
   974  func (m *RouteList) Size() (n int) {
   975  	if m == nil {
   976  		return 0
   977  	}
   978  	var l int
   979  	_ = l
   980  	l = m.ListMeta.Size()
   981  	n += 1 + l + sovGenerated(uint64(l))
   982  	if len(m.Items) > 0 {
   983  		for _, e := range m.Items {
   984  			l = e.Size()
   985  			n += 1 + l + sovGenerated(uint64(l))
   986  		}
   987  	}
   988  	return n
   989  }
   990  
   991  func (m *RoutePort) Size() (n int) {
   992  	if m == nil {
   993  		return 0
   994  	}
   995  	var l int
   996  	_ = l
   997  	l = m.TargetPort.Size()
   998  	n += 1 + l + sovGenerated(uint64(l))
   999  	return n
  1000  }
  1001  
  1002  func (m *RouteSpec) Size() (n int) {
  1003  	if m == nil {
  1004  		return 0
  1005  	}
  1006  	var l int
  1007  	_ = l
  1008  	l = len(m.Host)
  1009  	n += 1 + l + sovGenerated(uint64(l))
  1010  	l = len(m.Path)
  1011  	n += 1 + l + sovGenerated(uint64(l))
  1012  	l = m.To.Size()
  1013  	n += 1 + l + sovGenerated(uint64(l))
  1014  	if len(m.AlternateBackends) > 0 {
  1015  		for _, e := range m.AlternateBackends {
  1016  			l = e.Size()
  1017  			n += 1 + l + sovGenerated(uint64(l))
  1018  		}
  1019  	}
  1020  	if m.Port != nil {
  1021  		l = m.Port.Size()
  1022  		n += 1 + l + sovGenerated(uint64(l))
  1023  	}
  1024  	if m.TLS != nil {
  1025  		l = m.TLS.Size()
  1026  		n += 1 + l + sovGenerated(uint64(l))
  1027  	}
  1028  	l = len(m.WildcardPolicy)
  1029  	n += 1 + l + sovGenerated(uint64(l))
  1030  	l = len(m.Subdomain)
  1031  	n += 1 + l + sovGenerated(uint64(l))
  1032  	return n
  1033  }
  1034  
  1035  func (m *RouteStatus) Size() (n int) {
  1036  	if m == nil {
  1037  		return 0
  1038  	}
  1039  	var l int
  1040  	_ = l
  1041  	if len(m.Ingress) > 0 {
  1042  		for _, e := range m.Ingress {
  1043  			l = e.Size()
  1044  			n += 1 + l + sovGenerated(uint64(l))
  1045  		}
  1046  	}
  1047  	return n
  1048  }
  1049  
  1050  func (m *RouteTargetReference) Size() (n int) {
  1051  	if m == nil {
  1052  		return 0
  1053  	}
  1054  	var l int
  1055  	_ = l
  1056  	l = len(m.Kind)
  1057  	n += 1 + l + sovGenerated(uint64(l))
  1058  	l = len(m.Name)
  1059  	n += 1 + l + sovGenerated(uint64(l))
  1060  	if m.Weight != nil {
  1061  		n += 1 + sovGenerated(uint64(*m.Weight))
  1062  	}
  1063  	return n
  1064  }
  1065  
  1066  func (m *RouterShard) Size() (n int) {
  1067  	if m == nil {
  1068  		return 0
  1069  	}
  1070  	var l int
  1071  	_ = l
  1072  	l = len(m.ShardName)
  1073  	n += 1 + l + sovGenerated(uint64(l))
  1074  	l = len(m.DNSSuffix)
  1075  	n += 1 + l + sovGenerated(uint64(l))
  1076  	return n
  1077  }
  1078  
  1079  func (m *TLSConfig) Size() (n int) {
  1080  	if m == nil {
  1081  		return 0
  1082  	}
  1083  	var l int
  1084  	_ = l
  1085  	l = len(m.Termination)
  1086  	n += 1 + l + sovGenerated(uint64(l))
  1087  	l = len(m.Certificate)
  1088  	n += 1 + l + sovGenerated(uint64(l))
  1089  	l = len(m.Key)
  1090  	n += 1 + l + sovGenerated(uint64(l))
  1091  	l = len(m.CACertificate)
  1092  	n += 1 + l + sovGenerated(uint64(l))
  1093  	l = len(m.DestinationCACertificate)
  1094  	n += 1 + l + sovGenerated(uint64(l))
  1095  	l = len(m.InsecureEdgeTerminationPolicy)
  1096  	n += 1 + l + sovGenerated(uint64(l))
  1097  	return n
  1098  }
  1099  
  1100  func sovGenerated(x uint64) (n int) {
  1101  	return (math_bits.Len64(x|1) + 6) / 7
  1102  }
  1103  func sozGenerated(x uint64) (n int) {
  1104  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1105  }
  1106  func (this *Route) String() string {
  1107  	if this == nil {
  1108  		return "nil"
  1109  	}
  1110  	s := strings.Join([]string{`&Route{`,
  1111  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1112  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "RouteSpec", "RouteSpec", 1), `&`, ``, 1) + `,`,
  1113  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "RouteStatus", "RouteStatus", 1), `&`, ``, 1) + `,`,
  1114  		`}`,
  1115  	}, "")
  1116  	return s
  1117  }
  1118  func (this *RouteIngress) String() string {
  1119  	if this == nil {
  1120  		return "nil"
  1121  	}
  1122  	repeatedStringForConditions := "[]RouteIngressCondition{"
  1123  	for _, f := range this.Conditions {
  1124  		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "RouteIngressCondition", "RouteIngressCondition", 1), `&`, ``, 1) + ","
  1125  	}
  1126  	repeatedStringForConditions += "}"
  1127  	s := strings.Join([]string{`&RouteIngress{`,
  1128  		`Host:` + fmt.Sprintf("%v", this.Host) + `,`,
  1129  		`RouterName:` + fmt.Sprintf("%v", this.RouterName) + `,`,
  1130  		`Conditions:` + repeatedStringForConditions + `,`,
  1131  		`WildcardPolicy:` + fmt.Sprintf("%v", this.WildcardPolicy) + `,`,
  1132  		`RouterCanonicalHostname:` + fmt.Sprintf("%v", this.RouterCanonicalHostname) + `,`,
  1133  		`}`,
  1134  	}, "")
  1135  	return s
  1136  }
  1137  func (this *RouteIngressCondition) String() string {
  1138  	if this == nil {
  1139  		return "nil"
  1140  	}
  1141  	s := strings.Join([]string{`&RouteIngressCondition{`,
  1142  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  1143  		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
  1144  		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
  1145  		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
  1146  		`LastTransitionTime:` + strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1) + `,`,
  1147  		`}`,
  1148  	}, "")
  1149  	return s
  1150  }
  1151  func (this *RouteList) String() string {
  1152  	if this == nil {
  1153  		return "nil"
  1154  	}
  1155  	repeatedStringForItems := "[]Route{"
  1156  	for _, f := range this.Items {
  1157  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Route", "Route", 1), `&`, ``, 1) + ","
  1158  	}
  1159  	repeatedStringForItems += "}"
  1160  	s := strings.Join([]string{`&RouteList{`,
  1161  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1162  		`Items:` + repeatedStringForItems + `,`,
  1163  		`}`,
  1164  	}, "")
  1165  	return s
  1166  }
  1167  func (this *RoutePort) String() string {
  1168  	if this == nil {
  1169  		return "nil"
  1170  	}
  1171  	s := strings.Join([]string{`&RoutePort{`,
  1172  		`TargetPort:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TargetPort), "IntOrString", "intstr.IntOrString", 1), `&`, ``, 1) + `,`,
  1173  		`}`,
  1174  	}, "")
  1175  	return s
  1176  }
  1177  func (this *RouteSpec) String() string {
  1178  	if this == nil {
  1179  		return "nil"
  1180  	}
  1181  	repeatedStringForAlternateBackends := "[]RouteTargetReference{"
  1182  	for _, f := range this.AlternateBackends {
  1183  		repeatedStringForAlternateBackends += strings.Replace(strings.Replace(f.String(), "RouteTargetReference", "RouteTargetReference", 1), `&`, ``, 1) + ","
  1184  	}
  1185  	repeatedStringForAlternateBackends += "}"
  1186  	s := strings.Join([]string{`&RouteSpec{`,
  1187  		`Host:` + fmt.Sprintf("%v", this.Host) + `,`,
  1188  		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
  1189  		`To:` + strings.Replace(strings.Replace(this.To.String(), "RouteTargetReference", "RouteTargetReference", 1), `&`, ``, 1) + `,`,
  1190  		`AlternateBackends:` + repeatedStringForAlternateBackends + `,`,
  1191  		`Port:` + strings.Replace(this.Port.String(), "RoutePort", "RoutePort", 1) + `,`,
  1192  		`TLS:` + strings.Replace(this.TLS.String(), "TLSConfig", "TLSConfig", 1) + `,`,
  1193  		`WildcardPolicy:` + fmt.Sprintf("%v", this.WildcardPolicy) + `,`,
  1194  		`Subdomain:` + fmt.Sprintf("%v", this.Subdomain) + `,`,
  1195  		`}`,
  1196  	}, "")
  1197  	return s
  1198  }
  1199  func (this *RouteStatus) String() string {
  1200  	if this == nil {
  1201  		return "nil"
  1202  	}
  1203  	repeatedStringForIngress := "[]RouteIngress{"
  1204  	for _, f := range this.Ingress {
  1205  		repeatedStringForIngress += strings.Replace(strings.Replace(f.String(), "RouteIngress", "RouteIngress", 1), `&`, ``, 1) + ","
  1206  	}
  1207  	repeatedStringForIngress += "}"
  1208  	s := strings.Join([]string{`&RouteStatus{`,
  1209  		`Ingress:` + repeatedStringForIngress + `,`,
  1210  		`}`,
  1211  	}, "")
  1212  	return s
  1213  }
  1214  func (this *RouteTargetReference) String() string {
  1215  	if this == nil {
  1216  		return "nil"
  1217  	}
  1218  	s := strings.Join([]string{`&RouteTargetReference{`,
  1219  		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
  1220  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  1221  		`Weight:` + valueToStringGenerated(this.Weight) + `,`,
  1222  		`}`,
  1223  	}, "")
  1224  	return s
  1225  }
  1226  func (this *RouterShard) String() string {
  1227  	if this == nil {
  1228  		return "nil"
  1229  	}
  1230  	s := strings.Join([]string{`&RouterShard{`,
  1231  		`ShardName:` + fmt.Sprintf("%v", this.ShardName) + `,`,
  1232  		`DNSSuffix:` + fmt.Sprintf("%v", this.DNSSuffix) + `,`,
  1233  		`}`,
  1234  	}, "")
  1235  	return s
  1236  }
  1237  func (this *TLSConfig) String() string {
  1238  	if this == nil {
  1239  		return "nil"
  1240  	}
  1241  	s := strings.Join([]string{`&TLSConfig{`,
  1242  		`Termination:` + fmt.Sprintf("%v", this.Termination) + `,`,
  1243  		`Certificate:` + fmt.Sprintf("%v", this.Certificate) + `,`,
  1244  		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
  1245  		`CACertificate:` + fmt.Sprintf("%v", this.CACertificate) + `,`,
  1246  		`DestinationCACertificate:` + fmt.Sprintf("%v", this.DestinationCACertificate) + `,`,
  1247  		`InsecureEdgeTerminationPolicy:` + fmt.Sprintf("%v", this.InsecureEdgeTerminationPolicy) + `,`,
  1248  		`}`,
  1249  	}, "")
  1250  	return s
  1251  }
  1252  func valueToStringGenerated(v interface{}) string {
  1253  	rv := reflect.ValueOf(v)
  1254  	if rv.IsNil() {
  1255  		return "nil"
  1256  	}
  1257  	pv := reflect.Indirect(rv).Interface()
  1258  	return fmt.Sprintf("*%v", pv)
  1259  }
  1260  func (m *Route) Unmarshal(dAtA []byte) error {
  1261  	l := len(dAtA)
  1262  	iNdEx := 0
  1263  	for iNdEx < l {
  1264  		preIndex := iNdEx
  1265  		var wire uint64
  1266  		for shift := uint(0); ; shift += 7 {
  1267  			if shift >= 64 {
  1268  				return ErrIntOverflowGenerated
  1269  			}
  1270  			if iNdEx >= l {
  1271  				return io.ErrUnexpectedEOF
  1272  			}
  1273  			b := dAtA[iNdEx]
  1274  			iNdEx++
  1275  			wire |= uint64(b&0x7F) << shift
  1276  			if b < 0x80 {
  1277  				break
  1278  			}
  1279  		}
  1280  		fieldNum := int32(wire >> 3)
  1281  		wireType := int(wire & 0x7)
  1282  		if wireType == 4 {
  1283  			return fmt.Errorf("proto: Route: wiretype end group for non-group")
  1284  		}
  1285  		if fieldNum <= 0 {
  1286  			return fmt.Errorf("proto: Route: illegal tag %d (wire type %d)", fieldNum, wire)
  1287  		}
  1288  		switch fieldNum {
  1289  		case 1:
  1290  			if wireType != 2 {
  1291  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1292  			}
  1293  			var msglen int
  1294  			for shift := uint(0); ; shift += 7 {
  1295  				if shift >= 64 {
  1296  					return ErrIntOverflowGenerated
  1297  				}
  1298  				if iNdEx >= l {
  1299  					return io.ErrUnexpectedEOF
  1300  				}
  1301  				b := dAtA[iNdEx]
  1302  				iNdEx++
  1303  				msglen |= int(b&0x7F) << shift
  1304  				if b < 0x80 {
  1305  					break
  1306  				}
  1307  			}
  1308  			if msglen < 0 {
  1309  				return ErrInvalidLengthGenerated
  1310  			}
  1311  			postIndex := iNdEx + msglen
  1312  			if postIndex < 0 {
  1313  				return ErrInvalidLengthGenerated
  1314  			}
  1315  			if postIndex > l {
  1316  				return io.ErrUnexpectedEOF
  1317  			}
  1318  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1319  				return err
  1320  			}
  1321  			iNdEx = postIndex
  1322  		case 2:
  1323  			if wireType != 2 {
  1324  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  1325  			}
  1326  			var msglen int
  1327  			for shift := uint(0); ; shift += 7 {
  1328  				if shift >= 64 {
  1329  					return ErrIntOverflowGenerated
  1330  				}
  1331  				if iNdEx >= l {
  1332  					return io.ErrUnexpectedEOF
  1333  				}
  1334  				b := dAtA[iNdEx]
  1335  				iNdEx++
  1336  				msglen |= int(b&0x7F) << shift
  1337  				if b < 0x80 {
  1338  					break
  1339  				}
  1340  			}
  1341  			if msglen < 0 {
  1342  				return ErrInvalidLengthGenerated
  1343  			}
  1344  			postIndex := iNdEx + msglen
  1345  			if postIndex < 0 {
  1346  				return ErrInvalidLengthGenerated
  1347  			}
  1348  			if postIndex > l {
  1349  				return io.ErrUnexpectedEOF
  1350  			}
  1351  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1352  				return err
  1353  			}
  1354  			iNdEx = postIndex
  1355  		case 3:
  1356  			if wireType != 2 {
  1357  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  1358  			}
  1359  			var msglen int
  1360  			for shift := uint(0); ; shift += 7 {
  1361  				if shift >= 64 {
  1362  					return ErrIntOverflowGenerated
  1363  				}
  1364  				if iNdEx >= l {
  1365  					return io.ErrUnexpectedEOF
  1366  				}
  1367  				b := dAtA[iNdEx]
  1368  				iNdEx++
  1369  				msglen |= int(b&0x7F) << shift
  1370  				if b < 0x80 {
  1371  					break
  1372  				}
  1373  			}
  1374  			if msglen < 0 {
  1375  				return ErrInvalidLengthGenerated
  1376  			}
  1377  			postIndex := iNdEx + msglen
  1378  			if postIndex < 0 {
  1379  				return ErrInvalidLengthGenerated
  1380  			}
  1381  			if postIndex > l {
  1382  				return io.ErrUnexpectedEOF
  1383  			}
  1384  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1385  				return err
  1386  			}
  1387  			iNdEx = postIndex
  1388  		default:
  1389  			iNdEx = preIndex
  1390  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1391  			if err != nil {
  1392  				return err
  1393  			}
  1394  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1395  				return ErrInvalidLengthGenerated
  1396  			}
  1397  			if (iNdEx + skippy) > l {
  1398  				return io.ErrUnexpectedEOF
  1399  			}
  1400  			iNdEx += skippy
  1401  		}
  1402  	}
  1403  
  1404  	if iNdEx > l {
  1405  		return io.ErrUnexpectedEOF
  1406  	}
  1407  	return nil
  1408  }
  1409  func (m *RouteIngress) Unmarshal(dAtA []byte) error {
  1410  	l := len(dAtA)
  1411  	iNdEx := 0
  1412  	for iNdEx < l {
  1413  		preIndex := iNdEx
  1414  		var wire uint64
  1415  		for shift := uint(0); ; shift += 7 {
  1416  			if shift >= 64 {
  1417  				return ErrIntOverflowGenerated
  1418  			}
  1419  			if iNdEx >= l {
  1420  				return io.ErrUnexpectedEOF
  1421  			}
  1422  			b := dAtA[iNdEx]
  1423  			iNdEx++
  1424  			wire |= uint64(b&0x7F) << shift
  1425  			if b < 0x80 {
  1426  				break
  1427  			}
  1428  		}
  1429  		fieldNum := int32(wire >> 3)
  1430  		wireType := int(wire & 0x7)
  1431  		if wireType == 4 {
  1432  			return fmt.Errorf("proto: RouteIngress: wiretype end group for non-group")
  1433  		}
  1434  		if fieldNum <= 0 {
  1435  			return fmt.Errorf("proto: RouteIngress: illegal tag %d (wire type %d)", fieldNum, wire)
  1436  		}
  1437  		switch fieldNum {
  1438  		case 1:
  1439  			if wireType != 2 {
  1440  				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
  1441  			}
  1442  			var stringLen uint64
  1443  			for shift := uint(0); ; shift += 7 {
  1444  				if shift >= 64 {
  1445  					return ErrIntOverflowGenerated
  1446  				}
  1447  				if iNdEx >= l {
  1448  					return io.ErrUnexpectedEOF
  1449  				}
  1450  				b := dAtA[iNdEx]
  1451  				iNdEx++
  1452  				stringLen |= uint64(b&0x7F) << shift
  1453  				if b < 0x80 {
  1454  					break
  1455  				}
  1456  			}
  1457  			intStringLen := int(stringLen)
  1458  			if intStringLen < 0 {
  1459  				return ErrInvalidLengthGenerated
  1460  			}
  1461  			postIndex := iNdEx + intStringLen
  1462  			if postIndex < 0 {
  1463  				return ErrInvalidLengthGenerated
  1464  			}
  1465  			if postIndex > l {
  1466  				return io.ErrUnexpectedEOF
  1467  			}
  1468  			m.Host = string(dAtA[iNdEx:postIndex])
  1469  			iNdEx = postIndex
  1470  		case 2:
  1471  			if wireType != 2 {
  1472  				return fmt.Errorf("proto: wrong wireType = %d for field RouterName", wireType)
  1473  			}
  1474  			var stringLen uint64
  1475  			for shift := uint(0); ; shift += 7 {
  1476  				if shift >= 64 {
  1477  					return ErrIntOverflowGenerated
  1478  				}
  1479  				if iNdEx >= l {
  1480  					return io.ErrUnexpectedEOF
  1481  				}
  1482  				b := dAtA[iNdEx]
  1483  				iNdEx++
  1484  				stringLen |= uint64(b&0x7F) << shift
  1485  				if b < 0x80 {
  1486  					break
  1487  				}
  1488  			}
  1489  			intStringLen := int(stringLen)
  1490  			if intStringLen < 0 {
  1491  				return ErrInvalidLengthGenerated
  1492  			}
  1493  			postIndex := iNdEx + intStringLen
  1494  			if postIndex < 0 {
  1495  				return ErrInvalidLengthGenerated
  1496  			}
  1497  			if postIndex > l {
  1498  				return io.ErrUnexpectedEOF
  1499  			}
  1500  			m.RouterName = string(dAtA[iNdEx:postIndex])
  1501  			iNdEx = postIndex
  1502  		case 3:
  1503  			if wireType != 2 {
  1504  				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
  1505  			}
  1506  			var msglen int
  1507  			for shift := uint(0); ; shift += 7 {
  1508  				if shift >= 64 {
  1509  					return ErrIntOverflowGenerated
  1510  				}
  1511  				if iNdEx >= l {
  1512  					return io.ErrUnexpectedEOF
  1513  				}
  1514  				b := dAtA[iNdEx]
  1515  				iNdEx++
  1516  				msglen |= int(b&0x7F) << shift
  1517  				if b < 0x80 {
  1518  					break
  1519  				}
  1520  			}
  1521  			if msglen < 0 {
  1522  				return ErrInvalidLengthGenerated
  1523  			}
  1524  			postIndex := iNdEx + msglen
  1525  			if postIndex < 0 {
  1526  				return ErrInvalidLengthGenerated
  1527  			}
  1528  			if postIndex > l {
  1529  				return io.ErrUnexpectedEOF
  1530  			}
  1531  			m.Conditions = append(m.Conditions, RouteIngressCondition{})
  1532  			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1533  				return err
  1534  			}
  1535  			iNdEx = postIndex
  1536  		case 4:
  1537  			if wireType != 2 {
  1538  				return fmt.Errorf("proto: wrong wireType = %d for field WildcardPolicy", wireType)
  1539  			}
  1540  			var stringLen uint64
  1541  			for shift := uint(0); ; shift += 7 {
  1542  				if shift >= 64 {
  1543  					return ErrIntOverflowGenerated
  1544  				}
  1545  				if iNdEx >= l {
  1546  					return io.ErrUnexpectedEOF
  1547  				}
  1548  				b := dAtA[iNdEx]
  1549  				iNdEx++
  1550  				stringLen |= uint64(b&0x7F) << shift
  1551  				if b < 0x80 {
  1552  					break
  1553  				}
  1554  			}
  1555  			intStringLen := int(stringLen)
  1556  			if intStringLen < 0 {
  1557  				return ErrInvalidLengthGenerated
  1558  			}
  1559  			postIndex := iNdEx + intStringLen
  1560  			if postIndex < 0 {
  1561  				return ErrInvalidLengthGenerated
  1562  			}
  1563  			if postIndex > l {
  1564  				return io.ErrUnexpectedEOF
  1565  			}
  1566  			m.WildcardPolicy = WildcardPolicyType(dAtA[iNdEx:postIndex])
  1567  			iNdEx = postIndex
  1568  		case 5:
  1569  			if wireType != 2 {
  1570  				return fmt.Errorf("proto: wrong wireType = %d for field RouterCanonicalHostname", wireType)
  1571  			}
  1572  			var stringLen uint64
  1573  			for shift := uint(0); ; shift += 7 {
  1574  				if shift >= 64 {
  1575  					return ErrIntOverflowGenerated
  1576  				}
  1577  				if iNdEx >= l {
  1578  					return io.ErrUnexpectedEOF
  1579  				}
  1580  				b := dAtA[iNdEx]
  1581  				iNdEx++
  1582  				stringLen |= uint64(b&0x7F) << shift
  1583  				if b < 0x80 {
  1584  					break
  1585  				}
  1586  			}
  1587  			intStringLen := int(stringLen)
  1588  			if intStringLen < 0 {
  1589  				return ErrInvalidLengthGenerated
  1590  			}
  1591  			postIndex := iNdEx + intStringLen
  1592  			if postIndex < 0 {
  1593  				return ErrInvalidLengthGenerated
  1594  			}
  1595  			if postIndex > l {
  1596  				return io.ErrUnexpectedEOF
  1597  			}
  1598  			m.RouterCanonicalHostname = string(dAtA[iNdEx:postIndex])
  1599  			iNdEx = postIndex
  1600  		default:
  1601  			iNdEx = preIndex
  1602  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1603  			if err != nil {
  1604  				return err
  1605  			}
  1606  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1607  				return ErrInvalidLengthGenerated
  1608  			}
  1609  			if (iNdEx + skippy) > l {
  1610  				return io.ErrUnexpectedEOF
  1611  			}
  1612  			iNdEx += skippy
  1613  		}
  1614  	}
  1615  
  1616  	if iNdEx > l {
  1617  		return io.ErrUnexpectedEOF
  1618  	}
  1619  	return nil
  1620  }
  1621  func (m *RouteIngressCondition) Unmarshal(dAtA []byte) error {
  1622  	l := len(dAtA)
  1623  	iNdEx := 0
  1624  	for iNdEx < l {
  1625  		preIndex := iNdEx
  1626  		var wire uint64
  1627  		for shift := uint(0); ; shift += 7 {
  1628  			if shift >= 64 {
  1629  				return ErrIntOverflowGenerated
  1630  			}
  1631  			if iNdEx >= l {
  1632  				return io.ErrUnexpectedEOF
  1633  			}
  1634  			b := dAtA[iNdEx]
  1635  			iNdEx++
  1636  			wire |= uint64(b&0x7F) << shift
  1637  			if b < 0x80 {
  1638  				break
  1639  			}
  1640  		}
  1641  		fieldNum := int32(wire >> 3)
  1642  		wireType := int(wire & 0x7)
  1643  		if wireType == 4 {
  1644  			return fmt.Errorf("proto: RouteIngressCondition: wiretype end group for non-group")
  1645  		}
  1646  		if fieldNum <= 0 {
  1647  			return fmt.Errorf("proto: RouteIngressCondition: illegal tag %d (wire type %d)", fieldNum, wire)
  1648  		}
  1649  		switch fieldNum {
  1650  		case 1:
  1651  			if wireType != 2 {
  1652  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  1653  			}
  1654  			var stringLen uint64
  1655  			for shift := uint(0); ; shift += 7 {
  1656  				if shift >= 64 {
  1657  					return ErrIntOverflowGenerated
  1658  				}
  1659  				if iNdEx >= l {
  1660  					return io.ErrUnexpectedEOF
  1661  				}
  1662  				b := dAtA[iNdEx]
  1663  				iNdEx++
  1664  				stringLen |= uint64(b&0x7F) << shift
  1665  				if b < 0x80 {
  1666  					break
  1667  				}
  1668  			}
  1669  			intStringLen := int(stringLen)
  1670  			if intStringLen < 0 {
  1671  				return ErrInvalidLengthGenerated
  1672  			}
  1673  			postIndex := iNdEx + intStringLen
  1674  			if postIndex < 0 {
  1675  				return ErrInvalidLengthGenerated
  1676  			}
  1677  			if postIndex > l {
  1678  				return io.ErrUnexpectedEOF
  1679  			}
  1680  			m.Type = RouteIngressConditionType(dAtA[iNdEx:postIndex])
  1681  			iNdEx = postIndex
  1682  		case 2:
  1683  			if wireType != 2 {
  1684  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  1685  			}
  1686  			var stringLen uint64
  1687  			for shift := uint(0); ; shift += 7 {
  1688  				if shift >= 64 {
  1689  					return ErrIntOverflowGenerated
  1690  				}
  1691  				if iNdEx >= l {
  1692  					return io.ErrUnexpectedEOF
  1693  				}
  1694  				b := dAtA[iNdEx]
  1695  				iNdEx++
  1696  				stringLen |= uint64(b&0x7F) << shift
  1697  				if b < 0x80 {
  1698  					break
  1699  				}
  1700  			}
  1701  			intStringLen := int(stringLen)
  1702  			if intStringLen < 0 {
  1703  				return ErrInvalidLengthGenerated
  1704  			}
  1705  			postIndex := iNdEx + intStringLen
  1706  			if postIndex < 0 {
  1707  				return ErrInvalidLengthGenerated
  1708  			}
  1709  			if postIndex > l {
  1710  				return io.ErrUnexpectedEOF
  1711  			}
  1712  			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
  1713  			iNdEx = postIndex
  1714  		case 3:
  1715  			if wireType != 2 {
  1716  				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
  1717  			}
  1718  			var stringLen uint64
  1719  			for shift := uint(0); ; shift += 7 {
  1720  				if shift >= 64 {
  1721  					return ErrIntOverflowGenerated
  1722  				}
  1723  				if iNdEx >= l {
  1724  					return io.ErrUnexpectedEOF
  1725  				}
  1726  				b := dAtA[iNdEx]
  1727  				iNdEx++
  1728  				stringLen |= uint64(b&0x7F) << shift
  1729  				if b < 0x80 {
  1730  					break
  1731  				}
  1732  			}
  1733  			intStringLen := int(stringLen)
  1734  			if intStringLen < 0 {
  1735  				return ErrInvalidLengthGenerated
  1736  			}
  1737  			postIndex := iNdEx + intStringLen
  1738  			if postIndex < 0 {
  1739  				return ErrInvalidLengthGenerated
  1740  			}
  1741  			if postIndex > l {
  1742  				return io.ErrUnexpectedEOF
  1743  			}
  1744  			m.Reason = string(dAtA[iNdEx:postIndex])
  1745  			iNdEx = postIndex
  1746  		case 4:
  1747  			if wireType != 2 {
  1748  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
  1749  			}
  1750  			var stringLen uint64
  1751  			for shift := uint(0); ; shift += 7 {
  1752  				if shift >= 64 {
  1753  					return ErrIntOverflowGenerated
  1754  				}
  1755  				if iNdEx >= l {
  1756  					return io.ErrUnexpectedEOF
  1757  				}
  1758  				b := dAtA[iNdEx]
  1759  				iNdEx++
  1760  				stringLen |= uint64(b&0x7F) << shift
  1761  				if b < 0x80 {
  1762  					break
  1763  				}
  1764  			}
  1765  			intStringLen := int(stringLen)
  1766  			if intStringLen < 0 {
  1767  				return ErrInvalidLengthGenerated
  1768  			}
  1769  			postIndex := iNdEx + intStringLen
  1770  			if postIndex < 0 {
  1771  				return ErrInvalidLengthGenerated
  1772  			}
  1773  			if postIndex > l {
  1774  				return io.ErrUnexpectedEOF
  1775  			}
  1776  			m.Message = string(dAtA[iNdEx:postIndex])
  1777  			iNdEx = postIndex
  1778  		case 5:
  1779  			if wireType != 2 {
  1780  				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
  1781  			}
  1782  			var msglen int
  1783  			for shift := uint(0); ; shift += 7 {
  1784  				if shift >= 64 {
  1785  					return ErrIntOverflowGenerated
  1786  				}
  1787  				if iNdEx >= l {
  1788  					return io.ErrUnexpectedEOF
  1789  				}
  1790  				b := dAtA[iNdEx]
  1791  				iNdEx++
  1792  				msglen |= int(b&0x7F) << shift
  1793  				if b < 0x80 {
  1794  					break
  1795  				}
  1796  			}
  1797  			if msglen < 0 {
  1798  				return ErrInvalidLengthGenerated
  1799  			}
  1800  			postIndex := iNdEx + msglen
  1801  			if postIndex < 0 {
  1802  				return ErrInvalidLengthGenerated
  1803  			}
  1804  			if postIndex > l {
  1805  				return io.ErrUnexpectedEOF
  1806  			}
  1807  			if m.LastTransitionTime == nil {
  1808  				m.LastTransitionTime = &v1.Time{}
  1809  			}
  1810  			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1811  				return err
  1812  			}
  1813  			iNdEx = postIndex
  1814  		default:
  1815  			iNdEx = preIndex
  1816  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1817  			if err != nil {
  1818  				return err
  1819  			}
  1820  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1821  				return ErrInvalidLengthGenerated
  1822  			}
  1823  			if (iNdEx + skippy) > l {
  1824  				return io.ErrUnexpectedEOF
  1825  			}
  1826  			iNdEx += skippy
  1827  		}
  1828  	}
  1829  
  1830  	if iNdEx > l {
  1831  		return io.ErrUnexpectedEOF
  1832  	}
  1833  	return nil
  1834  }
  1835  func (m *RouteList) Unmarshal(dAtA []byte) error {
  1836  	l := len(dAtA)
  1837  	iNdEx := 0
  1838  	for iNdEx < l {
  1839  		preIndex := iNdEx
  1840  		var wire uint64
  1841  		for shift := uint(0); ; shift += 7 {
  1842  			if shift >= 64 {
  1843  				return ErrIntOverflowGenerated
  1844  			}
  1845  			if iNdEx >= l {
  1846  				return io.ErrUnexpectedEOF
  1847  			}
  1848  			b := dAtA[iNdEx]
  1849  			iNdEx++
  1850  			wire |= uint64(b&0x7F) << shift
  1851  			if b < 0x80 {
  1852  				break
  1853  			}
  1854  		}
  1855  		fieldNum := int32(wire >> 3)
  1856  		wireType := int(wire & 0x7)
  1857  		if wireType == 4 {
  1858  			return fmt.Errorf("proto: RouteList: wiretype end group for non-group")
  1859  		}
  1860  		if fieldNum <= 0 {
  1861  			return fmt.Errorf("proto: RouteList: illegal tag %d (wire type %d)", fieldNum, wire)
  1862  		}
  1863  		switch fieldNum {
  1864  		case 1:
  1865  			if wireType != 2 {
  1866  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1867  			}
  1868  			var msglen int
  1869  			for shift := uint(0); ; shift += 7 {
  1870  				if shift >= 64 {
  1871  					return ErrIntOverflowGenerated
  1872  				}
  1873  				if iNdEx >= l {
  1874  					return io.ErrUnexpectedEOF
  1875  				}
  1876  				b := dAtA[iNdEx]
  1877  				iNdEx++
  1878  				msglen |= int(b&0x7F) << shift
  1879  				if b < 0x80 {
  1880  					break
  1881  				}
  1882  			}
  1883  			if msglen < 0 {
  1884  				return ErrInvalidLengthGenerated
  1885  			}
  1886  			postIndex := iNdEx + msglen
  1887  			if postIndex < 0 {
  1888  				return ErrInvalidLengthGenerated
  1889  			}
  1890  			if postIndex > l {
  1891  				return io.ErrUnexpectedEOF
  1892  			}
  1893  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1894  				return err
  1895  			}
  1896  			iNdEx = postIndex
  1897  		case 2:
  1898  			if wireType != 2 {
  1899  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1900  			}
  1901  			var msglen int
  1902  			for shift := uint(0); ; shift += 7 {
  1903  				if shift >= 64 {
  1904  					return ErrIntOverflowGenerated
  1905  				}
  1906  				if iNdEx >= l {
  1907  					return io.ErrUnexpectedEOF
  1908  				}
  1909  				b := dAtA[iNdEx]
  1910  				iNdEx++
  1911  				msglen |= int(b&0x7F) << shift
  1912  				if b < 0x80 {
  1913  					break
  1914  				}
  1915  			}
  1916  			if msglen < 0 {
  1917  				return ErrInvalidLengthGenerated
  1918  			}
  1919  			postIndex := iNdEx + msglen
  1920  			if postIndex < 0 {
  1921  				return ErrInvalidLengthGenerated
  1922  			}
  1923  			if postIndex > l {
  1924  				return io.ErrUnexpectedEOF
  1925  			}
  1926  			m.Items = append(m.Items, Route{})
  1927  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1928  				return err
  1929  			}
  1930  			iNdEx = postIndex
  1931  		default:
  1932  			iNdEx = preIndex
  1933  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1934  			if err != nil {
  1935  				return err
  1936  			}
  1937  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1938  				return ErrInvalidLengthGenerated
  1939  			}
  1940  			if (iNdEx + skippy) > l {
  1941  				return io.ErrUnexpectedEOF
  1942  			}
  1943  			iNdEx += skippy
  1944  		}
  1945  	}
  1946  
  1947  	if iNdEx > l {
  1948  		return io.ErrUnexpectedEOF
  1949  	}
  1950  	return nil
  1951  }
  1952  func (m *RoutePort) Unmarshal(dAtA []byte) error {
  1953  	l := len(dAtA)
  1954  	iNdEx := 0
  1955  	for iNdEx < l {
  1956  		preIndex := iNdEx
  1957  		var wire uint64
  1958  		for shift := uint(0); ; shift += 7 {
  1959  			if shift >= 64 {
  1960  				return ErrIntOverflowGenerated
  1961  			}
  1962  			if iNdEx >= l {
  1963  				return io.ErrUnexpectedEOF
  1964  			}
  1965  			b := dAtA[iNdEx]
  1966  			iNdEx++
  1967  			wire |= uint64(b&0x7F) << shift
  1968  			if b < 0x80 {
  1969  				break
  1970  			}
  1971  		}
  1972  		fieldNum := int32(wire >> 3)
  1973  		wireType := int(wire & 0x7)
  1974  		if wireType == 4 {
  1975  			return fmt.Errorf("proto: RoutePort: wiretype end group for non-group")
  1976  		}
  1977  		if fieldNum <= 0 {
  1978  			return fmt.Errorf("proto: RoutePort: illegal tag %d (wire type %d)", fieldNum, wire)
  1979  		}
  1980  		switch fieldNum {
  1981  		case 1:
  1982  			if wireType != 2 {
  1983  				return fmt.Errorf("proto: wrong wireType = %d for field TargetPort", wireType)
  1984  			}
  1985  			var msglen int
  1986  			for shift := uint(0); ; shift += 7 {
  1987  				if shift >= 64 {
  1988  					return ErrIntOverflowGenerated
  1989  				}
  1990  				if iNdEx >= l {
  1991  					return io.ErrUnexpectedEOF
  1992  				}
  1993  				b := dAtA[iNdEx]
  1994  				iNdEx++
  1995  				msglen |= int(b&0x7F) << shift
  1996  				if b < 0x80 {
  1997  					break
  1998  				}
  1999  			}
  2000  			if msglen < 0 {
  2001  				return ErrInvalidLengthGenerated
  2002  			}
  2003  			postIndex := iNdEx + msglen
  2004  			if postIndex < 0 {
  2005  				return ErrInvalidLengthGenerated
  2006  			}
  2007  			if postIndex > l {
  2008  				return io.ErrUnexpectedEOF
  2009  			}
  2010  			if err := m.TargetPort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2011  				return err
  2012  			}
  2013  			iNdEx = postIndex
  2014  		default:
  2015  			iNdEx = preIndex
  2016  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2017  			if err != nil {
  2018  				return err
  2019  			}
  2020  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2021  				return ErrInvalidLengthGenerated
  2022  			}
  2023  			if (iNdEx + skippy) > l {
  2024  				return io.ErrUnexpectedEOF
  2025  			}
  2026  			iNdEx += skippy
  2027  		}
  2028  	}
  2029  
  2030  	if iNdEx > l {
  2031  		return io.ErrUnexpectedEOF
  2032  	}
  2033  	return nil
  2034  }
  2035  func (m *RouteSpec) Unmarshal(dAtA []byte) error {
  2036  	l := len(dAtA)
  2037  	iNdEx := 0
  2038  	for iNdEx < l {
  2039  		preIndex := iNdEx
  2040  		var wire uint64
  2041  		for shift := uint(0); ; shift += 7 {
  2042  			if shift >= 64 {
  2043  				return ErrIntOverflowGenerated
  2044  			}
  2045  			if iNdEx >= l {
  2046  				return io.ErrUnexpectedEOF
  2047  			}
  2048  			b := dAtA[iNdEx]
  2049  			iNdEx++
  2050  			wire |= uint64(b&0x7F) << shift
  2051  			if b < 0x80 {
  2052  				break
  2053  			}
  2054  		}
  2055  		fieldNum := int32(wire >> 3)
  2056  		wireType := int(wire & 0x7)
  2057  		if wireType == 4 {
  2058  			return fmt.Errorf("proto: RouteSpec: wiretype end group for non-group")
  2059  		}
  2060  		if fieldNum <= 0 {
  2061  			return fmt.Errorf("proto: RouteSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  2062  		}
  2063  		switch fieldNum {
  2064  		case 1:
  2065  			if wireType != 2 {
  2066  				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
  2067  			}
  2068  			var stringLen uint64
  2069  			for shift := uint(0); ; shift += 7 {
  2070  				if shift >= 64 {
  2071  					return ErrIntOverflowGenerated
  2072  				}
  2073  				if iNdEx >= l {
  2074  					return io.ErrUnexpectedEOF
  2075  				}
  2076  				b := dAtA[iNdEx]
  2077  				iNdEx++
  2078  				stringLen |= uint64(b&0x7F) << shift
  2079  				if b < 0x80 {
  2080  					break
  2081  				}
  2082  			}
  2083  			intStringLen := int(stringLen)
  2084  			if intStringLen < 0 {
  2085  				return ErrInvalidLengthGenerated
  2086  			}
  2087  			postIndex := iNdEx + intStringLen
  2088  			if postIndex < 0 {
  2089  				return ErrInvalidLengthGenerated
  2090  			}
  2091  			if postIndex > l {
  2092  				return io.ErrUnexpectedEOF
  2093  			}
  2094  			m.Host = string(dAtA[iNdEx:postIndex])
  2095  			iNdEx = postIndex
  2096  		case 2:
  2097  			if wireType != 2 {
  2098  				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
  2099  			}
  2100  			var stringLen uint64
  2101  			for shift := uint(0); ; shift += 7 {
  2102  				if shift >= 64 {
  2103  					return ErrIntOverflowGenerated
  2104  				}
  2105  				if iNdEx >= l {
  2106  					return io.ErrUnexpectedEOF
  2107  				}
  2108  				b := dAtA[iNdEx]
  2109  				iNdEx++
  2110  				stringLen |= uint64(b&0x7F) << shift
  2111  				if b < 0x80 {
  2112  					break
  2113  				}
  2114  			}
  2115  			intStringLen := int(stringLen)
  2116  			if intStringLen < 0 {
  2117  				return ErrInvalidLengthGenerated
  2118  			}
  2119  			postIndex := iNdEx + intStringLen
  2120  			if postIndex < 0 {
  2121  				return ErrInvalidLengthGenerated
  2122  			}
  2123  			if postIndex > l {
  2124  				return io.ErrUnexpectedEOF
  2125  			}
  2126  			m.Path = string(dAtA[iNdEx:postIndex])
  2127  			iNdEx = postIndex
  2128  		case 3:
  2129  			if wireType != 2 {
  2130  				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
  2131  			}
  2132  			var msglen int
  2133  			for shift := uint(0); ; shift += 7 {
  2134  				if shift >= 64 {
  2135  					return ErrIntOverflowGenerated
  2136  				}
  2137  				if iNdEx >= l {
  2138  					return io.ErrUnexpectedEOF
  2139  				}
  2140  				b := dAtA[iNdEx]
  2141  				iNdEx++
  2142  				msglen |= int(b&0x7F) << shift
  2143  				if b < 0x80 {
  2144  					break
  2145  				}
  2146  			}
  2147  			if msglen < 0 {
  2148  				return ErrInvalidLengthGenerated
  2149  			}
  2150  			postIndex := iNdEx + msglen
  2151  			if postIndex < 0 {
  2152  				return ErrInvalidLengthGenerated
  2153  			}
  2154  			if postIndex > l {
  2155  				return io.ErrUnexpectedEOF
  2156  			}
  2157  			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2158  				return err
  2159  			}
  2160  			iNdEx = postIndex
  2161  		case 4:
  2162  			if wireType != 2 {
  2163  				return fmt.Errorf("proto: wrong wireType = %d for field AlternateBackends", wireType)
  2164  			}
  2165  			var msglen int
  2166  			for shift := uint(0); ; shift += 7 {
  2167  				if shift >= 64 {
  2168  					return ErrIntOverflowGenerated
  2169  				}
  2170  				if iNdEx >= l {
  2171  					return io.ErrUnexpectedEOF
  2172  				}
  2173  				b := dAtA[iNdEx]
  2174  				iNdEx++
  2175  				msglen |= int(b&0x7F) << shift
  2176  				if b < 0x80 {
  2177  					break
  2178  				}
  2179  			}
  2180  			if msglen < 0 {
  2181  				return ErrInvalidLengthGenerated
  2182  			}
  2183  			postIndex := iNdEx + msglen
  2184  			if postIndex < 0 {
  2185  				return ErrInvalidLengthGenerated
  2186  			}
  2187  			if postIndex > l {
  2188  				return io.ErrUnexpectedEOF
  2189  			}
  2190  			m.AlternateBackends = append(m.AlternateBackends, RouteTargetReference{})
  2191  			if err := m.AlternateBackends[len(m.AlternateBackends)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2192  				return err
  2193  			}
  2194  			iNdEx = postIndex
  2195  		case 5:
  2196  			if wireType != 2 {
  2197  				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
  2198  			}
  2199  			var msglen int
  2200  			for shift := uint(0); ; shift += 7 {
  2201  				if shift >= 64 {
  2202  					return ErrIntOverflowGenerated
  2203  				}
  2204  				if iNdEx >= l {
  2205  					return io.ErrUnexpectedEOF
  2206  				}
  2207  				b := dAtA[iNdEx]
  2208  				iNdEx++
  2209  				msglen |= int(b&0x7F) << shift
  2210  				if b < 0x80 {
  2211  					break
  2212  				}
  2213  			}
  2214  			if msglen < 0 {
  2215  				return ErrInvalidLengthGenerated
  2216  			}
  2217  			postIndex := iNdEx + msglen
  2218  			if postIndex < 0 {
  2219  				return ErrInvalidLengthGenerated
  2220  			}
  2221  			if postIndex > l {
  2222  				return io.ErrUnexpectedEOF
  2223  			}
  2224  			if m.Port == nil {
  2225  				m.Port = &RoutePort{}
  2226  			}
  2227  			if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2228  				return err
  2229  			}
  2230  			iNdEx = postIndex
  2231  		case 6:
  2232  			if wireType != 2 {
  2233  				return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType)
  2234  			}
  2235  			var msglen int
  2236  			for shift := uint(0); ; shift += 7 {
  2237  				if shift >= 64 {
  2238  					return ErrIntOverflowGenerated
  2239  				}
  2240  				if iNdEx >= l {
  2241  					return io.ErrUnexpectedEOF
  2242  				}
  2243  				b := dAtA[iNdEx]
  2244  				iNdEx++
  2245  				msglen |= int(b&0x7F) << shift
  2246  				if b < 0x80 {
  2247  					break
  2248  				}
  2249  			}
  2250  			if msglen < 0 {
  2251  				return ErrInvalidLengthGenerated
  2252  			}
  2253  			postIndex := iNdEx + msglen
  2254  			if postIndex < 0 {
  2255  				return ErrInvalidLengthGenerated
  2256  			}
  2257  			if postIndex > l {
  2258  				return io.ErrUnexpectedEOF
  2259  			}
  2260  			if m.TLS == nil {
  2261  				m.TLS = &TLSConfig{}
  2262  			}
  2263  			if err := m.TLS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2264  				return err
  2265  			}
  2266  			iNdEx = postIndex
  2267  		case 7:
  2268  			if wireType != 2 {
  2269  				return fmt.Errorf("proto: wrong wireType = %d for field WildcardPolicy", wireType)
  2270  			}
  2271  			var stringLen uint64
  2272  			for shift := uint(0); ; shift += 7 {
  2273  				if shift >= 64 {
  2274  					return ErrIntOverflowGenerated
  2275  				}
  2276  				if iNdEx >= l {
  2277  					return io.ErrUnexpectedEOF
  2278  				}
  2279  				b := dAtA[iNdEx]
  2280  				iNdEx++
  2281  				stringLen |= uint64(b&0x7F) << shift
  2282  				if b < 0x80 {
  2283  					break
  2284  				}
  2285  			}
  2286  			intStringLen := int(stringLen)
  2287  			if intStringLen < 0 {
  2288  				return ErrInvalidLengthGenerated
  2289  			}
  2290  			postIndex := iNdEx + intStringLen
  2291  			if postIndex < 0 {
  2292  				return ErrInvalidLengthGenerated
  2293  			}
  2294  			if postIndex > l {
  2295  				return io.ErrUnexpectedEOF
  2296  			}
  2297  			m.WildcardPolicy = WildcardPolicyType(dAtA[iNdEx:postIndex])
  2298  			iNdEx = postIndex
  2299  		case 8:
  2300  			if wireType != 2 {
  2301  				return fmt.Errorf("proto: wrong wireType = %d for field Subdomain", wireType)
  2302  			}
  2303  			var stringLen uint64
  2304  			for shift := uint(0); ; shift += 7 {
  2305  				if shift >= 64 {
  2306  					return ErrIntOverflowGenerated
  2307  				}
  2308  				if iNdEx >= l {
  2309  					return io.ErrUnexpectedEOF
  2310  				}
  2311  				b := dAtA[iNdEx]
  2312  				iNdEx++
  2313  				stringLen |= uint64(b&0x7F) << shift
  2314  				if b < 0x80 {
  2315  					break
  2316  				}
  2317  			}
  2318  			intStringLen := int(stringLen)
  2319  			if intStringLen < 0 {
  2320  				return ErrInvalidLengthGenerated
  2321  			}
  2322  			postIndex := iNdEx + intStringLen
  2323  			if postIndex < 0 {
  2324  				return ErrInvalidLengthGenerated
  2325  			}
  2326  			if postIndex > l {
  2327  				return io.ErrUnexpectedEOF
  2328  			}
  2329  			m.Subdomain = string(dAtA[iNdEx:postIndex])
  2330  			iNdEx = postIndex
  2331  		default:
  2332  			iNdEx = preIndex
  2333  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2334  			if err != nil {
  2335  				return err
  2336  			}
  2337  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2338  				return ErrInvalidLengthGenerated
  2339  			}
  2340  			if (iNdEx + skippy) > l {
  2341  				return io.ErrUnexpectedEOF
  2342  			}
  2343  			iNdEx += skippy
  2344  		}
  2345  	}
  2346  
  2347  	if iNdEx > l {
  2348  		return io.ErrUnexpectedEOF
  2349  	}
  2350  	return nil
  2351  }
  2352  func (m *RouteStatus) Unmarshal(dAtA []byte) error {
  2353  	l := len(dAtA)
  2354  	iNdEx := 0
  2355  	for iNdEx < l {
  2356  		preIndex := iNdEx
  2357  		var wire uint64
  2358  		for shift := uint(0); ; shift += 7 {
  2359  			if shift >= 64 {
  2360  				return ErrIntOverflowGenerated
  2361  			}
  2362  			if iNdEx >= l {
  2363  				return io.ErrUnexpectedEOF
  2364  			}
  2365  			b := dAtA[iNdEx]
  2366  			iNdEx++
  2367  			wire |= uint64(b&0x7F) << shift
  2368  			if b < 0x80 {
  2369  				break
  2370  			}
  2371  		}
  2372  		fieldNum := int32(wire >> 3)
  2373  		wireType := int(wire & 0x7)
  2374  		if wireType == 4 {
  2375  			return fmt.Errorf("proto: RouteStatus: wiretype end group for non-group")
  2376  		}
  2377  		if fieldNum <= 0 {
  2378  			return fmt.Errorf("proto: RouteStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  2379  		}
  2380  		switch fieldNum {
  2381  		case 1:
  2382  			if wireType != 2 {
  2383  				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
  2384  			}
  2385  			var msglen int
  2386  			for shift := uint(0); ; shift += 7 {
  2387  				if shift >= 64 {
  2388  					return ErrIntOverflowGenerated
  2389  				}
  2390  				if iNdEx >= l {
  2391  					return io.ErrUnexpectedEOF
  2392  				}
  2393  				b := dAtA[iNdEx]
  2394  				iNdEx++
  2395  				msglen |= int(b&0x7F) << shift
  2396  				if b < 0x80 {
  2397  					break
  2398  				}
  2399  			}
  2400  			if msglen < 0 {
  2401  				return ErrInvalidLengthGenerated
  2402  			}
  2403  			postIndex := iNdEx + msglen
  2404  			if postIndex < 0 {
  2405  				return ErrInvalidLengthGenerated
  2406  			}
  2407  			if postIndex > l {
  2408  				return io.ErrUnexpectedEOF
  2409  			}
  2410  			m.Ingress = append(m.Ingress, RouteIngress{})
  2411  			if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2412  				return err
  2413  			}
  2414  			iNdEx = postIndex
  2415  		default:
  2416  			iNdEx = preIndex
  2417  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2418  			if err != nil {
  2419  				return err
  2420  			}
  2421  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2422  				return ErrInvalidLengthGenerated
  2423  			}
  2424  			if (iNdEx + skippy) > l {
  2425  				return io.ErrUnexpectedEOF
  2426  			}
  2427  			iNdEx += skippy
  2428  		}
  2429  	}
  2430  
  2431  	if iNdEx > l {
  2432  		return io.ErrUnexpectedEOF
  2433  	}
  2434  	return nil
  2435  }
  2436  func (m *RouteTargetReference) Unmarshal(dAtA []byte) error {
  2437  	l := len(dAtA)
  2438  	iNdEx := 0
  2439  	for iNdEx < l {
  2440  		preIndex := iNdEx
  2441  		var wire uint64
  2442  		for shift := uint(0); ; shift += 7 {
  2443  			if shift >= 64 {
  2444  				return ErrIntOverflowGenerated
  2445  			}
  2446  			if iNdEx >= l {
  2447  				return io.ErrUnexpectedEOF
  2448  			}
  2449  			b := dAtA[iNdEx]
  2450  			iNdEx++
  2451  			wire |= uint64(b&0x7F) << shift
  2452  			if b < 0x80 {
  2453  				break
  2454  			}
  2455  		}
  2456  		fieldNum := int32(wire >> 3)
  2457  		wireType := int(wire & 0x7)
  2458  		if wireType == 4 {
  2459  			return fmt.Errorf("proto: RouteTargetReference: wiretype end group for non-group")
  2460  		}
  2461  		if fieldNum <= 0 {
  2462  			return fmt.Errorf("proto: RouteTargetReference: illegal tag %d (wire type %d)", fieldNum, wire)
  2463  		}
  2464  		switch fieldNum {
  2465  		case 1:
  2466  			if wireType != 2 {
  2467  				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
  2468  			}
  2469  			var stringLen uint64
  2470  			for shift := uint(0); ; shift += 7 {
  2471  				if shift >= 64 {
  2472  					return ErrIntOverflowGenerated
  2473  				}
  2474  				if iNdEx >= l {
  2475  					return io.ErrUnexpectedEOF
  2476  				}
  2477  				b := dAtA[iNdEx]
  2478  				iNdEx++
  2479  				stringLen |= uint64(b&0x7F) << shift
  2480  				if b < 0x80 {
  2481  					break
  2482  				}
  2483  			}
  2484  			intStringLen := int(stringLen)
  2485  			if intStringLen < 0 {
  2486  				return ErrInvalidLengthGenerated
  2487  			}
  2488  			postIndex := iNdEx + intStringLen
  2489  			if postIndex < 0 {
  2490  				return ErrInvalidLengthGenerated
  2491  			}
  2492  			if postIndex > l {
  2493  				return io.ErrUnexpectedEOF
  2494  			}
  2495  			m.Kind = string(dAtA[iNdEx:postIndex])
  2496  			iNdEx = postIndex
  2497  		case 2:
  2498  			if wireType != 2 {
  2499  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  2500  			}
  2501  			var stringLen uint64
  2502  			for shift := uint(0); ; shift += 7 {
  2503  				if shift >= 64 {
  2504  					return ErrIntOverflowGenerated
  2505  				}
  2506  				if iNdEx >= l {
  2507  					return io.ErrUnexpectedEOF
  2508  				}
  2509  				b := dAtA[iNdEx]
  2510  				iNdEx++
  2511  				stringLen |= uint64(b&0x7F) << shift
  2512  				if b < 0x80 {
  2513  					break
  2514  				}
  2515  			}
  2516  			intStringLen := int(stringLen)
  2517  			if intStringLen < 0 {
  2518  				return ErrInvalidLengthGenerated
  2519  			}
  2520  			postIndex := iNdEx + intStringLen
  2521  			if postIndex < 0 {
  2522  				return ErrInvalidLengthGenerated
  2523  			}
  2524  			if postIndex > l {
  2525  				return io.ErrUnexpectedEOF
  2526  			}
  2527  			m.Name = string(dAtA[iNdEx:postIndex])
  2528  			iNdEx = postIndex
  2529  		case 3:
  2530  			if wireType != 0 {
  2531  				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
  2532  			}
  2533  			var v int32
  2534  			for shift := uint(0); ; shift += 7 {
  2535  				if shift >= 64 {
  2536  					return ErrIntOverflowGenerated
  2537  				}
  2538  				if iNdEx >= l {
  2539  					return io.ErrUnexpectedEOF
  2540  				}
  2541  				b := dAtA[iNdEx]
  2542  				iNdEx++
  2543  				v |= int32(b&0x7F) << shift
  2544  				if b < 0x80 {
  2545  					break
  2546  				}
  2547  			}
  2548  			m.Weight = &v
  2549  		default:
  2550  			iNdEx = preIndex
  2551  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2552  			if err != nil {
  2553  				return err
  2554  			}
  2555  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2556  				return ErrInvalidLengthGenerated
  2557  			}
  2558  			if (iNdEx + skippy) > l {
  2559  				return io.ErrUnexpectedEOF
  2560  			}
  2561  			iNdEx += skippy
  2562  		}
  2563  	}
  2564  
  2565  	if iNdEx > l {
  2566  		return io.ErrUnexpectedEOF
  2567  	}
  2568  	return nil
  2569  }
  2570  func (m *RouterShard) Unmarshal(dAtA []byte) error {
  2571  	l := len(dAtA)
  2572  	iNdEx := 0
  2573  	for iNdEx < l {
  2574  		preIndex := iNdEx
  2575  		var wire uint64
  2576  		for shift := uint(0); ; shift += 7 {
  2577  			if shift >= 64 {
  2578  				return ErrIntOverflowGenerated
  2579  			}
  2580  			if iNdEx >= l {
  2581  				return io.ErrUnexpectedEOF
  2582  			}
  2583  			b := dAtA[iNdEx]
  2584  			iNdEx++
  2585  			wire |= uint64(b&0x7F) << shift
  2586  			if b < 0x80 {
  2587  				break
  2588  			}
  2589  		}
  2590  		fieldNum := int32(wire >> 3)
  2591  		wireType := int(wire & 0x7)
  2592  		if wireType == 4 {
  2593  			return fmt.Errorf("proto: RouterShard: wiretype end group for non-group")
  2594  		}
  2595  		if fieldNum <= 0 {
  2596  			return fmt.Errorf("proto: RouterShard: illegal tag %d (wire type %d)", fieldNum, wire)
  2597  		}
  2598  		switch fieldNum {
  2599  		case 1:
  2600  			if wireType != 2 {
  2601  				return fmt.Errorf("proto: wrong wireType = %d for field ShardName", wireType)
  2602  			}
  2603  			var stringLen uint64
  2604  			for shift := uint(0); ; shift += 7 {
  2605  				if shift >= 64 {
  2606  					return ErrIntOverflowGenerated
  2607  				}
  2608  				if iNdEx >= l {
  2609  					return io.ErrUnexpectedEOF
  2610  				}
  2611  				b := dAtA[iNdEx]
  2612  				iNdEx++
  2613  				stringLen |= uint64(b&0x7F) << shift
  2614  				if b < 0x80 {
  2615  					break
  2616  				}
  2617  			}
  2618  			intStringLen := int(stringLen)
  2619  			if intStringLen < 0 {
  2620  				return ErrInvalidLengthGenerated
  2621  			}
  2622  			postIndex := iNdEx + intStringLen
  2623  			if postIndex < 0 {
  2624  				return ErrInvalidLengthGenerated
  2625  			}
  2626  			if postIndex > l {
  2627  				return io.ErrUnexpectedEOF
  2628  			}
  2629  			m.ShardName = string(dAtA[iNdEx:postIndex])
  2630  			iNdEx = postIndex
  2631  		case 2:
  2632  			if wireType != 2 {
  2633  				return fmt.Errorf("proto: wrong wireType = %d for field DNSSuffix", wireType)
  2634  			}
  2635  			var stringLen uint64
  2636  			for shift := uint(0); ; shift += 7 {
  2637  				if shift >= 64 {
  2638  					return ErrIntOverflowGenerated
  2639  				}
  2640  				if iNdEx >= l {
  2641  					return io.ErrUnexpectedEOF
  2642  				}
  2643  				b := dAtA[iNdEx]
  2644  				iNdEx++
  2645  				stringLen |= uint64(b&0x7F) << shift
  2646  				if b < 0x80 {
  2647  					break
  2648  				}
  2649  			}
  2650  			intStringLen := int(stringLen)
  2651  			if intStringLen < 0 {
  2652  				return ErrInvalidLengthGenerated
  2653  			}
  2654  			postIndex := iNdEx + intStringLen
  2655  			if postIndex < 0 {
  2656  				return ErrInvalidLengthGenerated
  2657  			}
  2658  			if postIndex > l {
  2659  				return io.ErrUnexpectedEOF
  2660  			}
  2661  			m.DNSSuffix = string(dAtA[iNdEx:postIndex])
  2662  			iNdEx = postIndex
  2663  		default:
  2664  			iNdEx = preIndex
  2665  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2666  			if err != nil {
  2667  				return err
  2668  			}
  2669  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2670  				return ErrInvalidLengthGenerated
  2671  			}
  2672  			if (iNdEx + skippy) > l {
  2673  				return io.ErrUnexpectedEOF
  2674  			}
  2675  			iNdEx += skippy
  2676  		}
  2677  	}
  2678  
  2679  	if iNdEx > l {
  2680  		return io.ErrUnexpectedEOF
  2681  	}
  2682  	return nil
  2683  }
  2684  func (m *TLSConfig) Unmarshal(dAtA []byte) error {
  2685  	l := len(dAtA)
  2686  	iNdEx := 0
  2687  	for iNdEx < l {
  2688  		preIndex := iNdEx
  2689  		var wire uint64
  2690  		for shift := uint(0); ; shift += 7 {
  2691  			if shift >= 64 {
  2692  				return ErrIntOverflowGenerated
  2693  			}
  2694  			if iNdEx >= l {
  2695  				return io.ErrUnexpectedEOF
  2696  			}
  2697  			b := dAtA[iNdEx]
  2698  			iNdEx++
  2699  			wire |= uint64(b&0x7F) << shift
  2700  			if b < 0x80 {
  2701  				break
  2702  			}
  2703  		}
  2704  		fieldNum := int32(wire >> 3)
  2705  		wireType := int(wire & 0x7)
  2706  		if wireType == 4 {
  2707  			return fmt.Errorf("proto: TLSConfig: wiretype end group for non-group")
  2708  		}
  2709  		if fieldNum <= 0 {
  2710  			return fmt.Errorf("proto: TLSConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  2711  		}
  2712  		switch fieldNum {
  2713  		case 1:
  2714  			if wireType != 2 {
  2715  				return fmt.Errorf("proto: wrong wireType = %d for field Termination", wireType)
  2716  			}
  2717  			var stringLen uint64
  2718  			for shift := uint(0); ; shift += 7 {
  2719  				if shift >= 64 {
  2720  					return ErrIntOverflowGenerated
  2721  				}
  2722  				if iNdEx >= l {
  2723  					return io.ErrUnexpectedEOF
  2724  				}
  2725  				b := dAtA[iNdEx]
  2726  				iNdEx++
  2727  				stringLen |= uint64(b&0x7F) << shift
  2728  				if b < 0x80 {
  2729  					break
  2730  				}
  2731  			}
  2732  			intStringLen := int(stringLen)
  2733  			if intStringLen < 0 {
  2734  				return ErrInvalidLengthGenerated
  2735  			}
  2736  			postIndex := iNdEx + intStringLen
  2737  			if postIndex < 0 {
  2738  				return ErrInvalidLengthGenerated
  2739  			}
  2740  			if postIndex > l {
  2741  				return io.ErrUnexpectedEOF
  2742  			}
  2743  			m.Termination = TLSTerminationType(dAtA[iNdEx:postIndex])
  2744  			iNdEx = postIndex
  2745  		case 2:
  2746  			if wireType != 2 {
  2747  				return fmt.Errorf("proto: wrong wireType = %d for field Certificate", wireType)
  2748  			}
  2749  			var stringLen uint64
  2750  			for shift := uint(0); ; shift += 7 {
  2751  				if shift >= 64 {
  2752  					return ErrIntOverflowGenerated
  2753  				}
  2754  				if iNdEx >= l {
  2755  					return io.ErrUnexpectedEOF
  2756  				}
  2757  				b := dAtA[iNdEx]
  2758  				iNdEx++
  2759  				stringLen |= uint64(b&0x7F) << shift
  2760  				if b < 0x80 {
  2761  					break
  2762  				}
  2763  			}
  2764  			intStringLen := int(stringLen)
  2765  			if intStringLen < 0 {
  2766  				return ErrInvalidLengthGenerated
  2767  			}
  2768  			postIndex := iNdEx + intStringLen
  2769  			if postIndex < 0 {
  2770  				return ErrInvalidLengthGenerated
  2771  			}
  2772  			if postIndex > l {
  2773  				return io.ErrUnexpectedEOF
  2774  			}
  2775  			m.Certificate = string(dAtA[iNdEx:postIndex])
  2776  			iNdEx = postIndex
  2777  		case 3:
  2778  			if wireType != 2 {
  2779  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  2780  			}
  2781  			var stringLen uint64
  2782  			for shift := uint(0); ; shift += 7 {
  2783  				if shift >= 64 {
  2784  					return ErrIntOverflowGenerated
  2785  				}
  2786  				if iNdEx >= l {
  2787  					return io.ErrUnexpectedEOF
  2788  				}
  2789  				b := dAtA[iNdEx]
  2790  				iNdEx++
  2791  				stringLen |= uint64(b&0x7F) << shift
  2792  				if b < 0x80 {
  2793  					break
  2794  				}
  2795  			}
  2796  			intStringLen := int(stringLen)
  2797  			if intStringLen < 0 {
  2798  				return ErrInvalidLengthGenerated
  2799  			}
  2800  			postIndex := iNdEx + intStringLen
  2801  			if postIndex < 0 {
  2802  				return ErrInvalidLengthGenerated
  2803  			}
  2804  			if postIndex > l {
  2805  				return io.ErrUnexpectedEOF
  2806  			}
  2807  			m.Key = string(dAtA[iNdEx:postIndex])
  2808  			iNdEx = postIndex
  2809  		case 4:
  2810  			if wireType != 2 {
  2811  				return fmt.Errorf("proto: wrong wireType = %d for field CACertificate", wireType)
  2812  			}
  2813  			var stringLen uint64
  2814  			for shift := uint(0); ; shift += 7 {
  2815  				if shift >= 64 {
  2816  					return ErrIntOverflowGenerated
  2817  				}
  2818  				if iNdEx >= l {
  2819  					return io.ErrUnexpectedEOF
  2820  				}
  2821  				b := dAtA[iNdEx]
  2822  				iNdEx++
  2823  				stringLen |= uint64(b&0x7F) << shift
  2824  				if b < 0x80 {
  2825  					break
  2826  				}
  2827  			}
  2828  			intStringLen := int(stringLen)
  2829  			if intStringLen < 0 {
  2830  				return ErrInvalidLengthGenerated
  2831  			}
  2832  			postIndex := iNdEx + intStringLen
  2833  			if postIndex < 0 {
  2834  				return ErrInvalidLengthGenerated
  2835  			}
  2836  			if postIndex > l {
  2837  				return io.ErrUnexpectedEOF
  2838  			}
  2839  			m.CACertificate = string(dAtA[iNdEx:postIndex])
  2840  			iNdEx = postIndex
  2841  		case 5:
  2842  			if wireType != 2 {
  2843  				return fmt.Errorf("proto: wrong wireType = %d for field DestinationCACertificate", wireType)
  2844  			}
  2845  			var stringLen uint64
  2846  			for shift := uint(0); ; shift += 7 {
  2847  				if shift >= 64 {
  2848  					return ErrIntOverflowGenerated
  2849  				}
  2850  				if iNdEx >= l {
  2851  					return io.ErrUnexpectedEOF
  2852  				}
  2853  				b := dAtA[iNdEx]
  2854  				iNdEx++
  2855  				stringLen |= uint64(b&0x7F) << shift
  2856  				if b < 0x80 {
  2857  					break
  2858  				}
  2859  			}
  2860  			intStringLen := int(stringLen)
  2861  			if intStringLen < 0 {
  2862  				return ErrInvalidLengthGenerated
  2863  			}
  2864  			postIndex := iNdEx + intStringLen
  2865  			if postIndex < 0 {
  2866  				return ErrInvalidLengthGenerated
  2867  			}
  2868  			if postIndex > l {
  2869  				return io.ErrUnexpectedEOF
  2870  			}
  2871  			m.DestinationCACertificate = string(dAtA[iNdEx:postIndex])
  2872  			iNdEx = postIndex
  2873  		case 6:
  2874  			if wireType != 2 {
  2875  				return fmt.Errorf("proto: wrong wireType = %d for field InsecureEdgeTerminationPolicy", wireType)
  2876  			}
  2877  			var stringLen uint64
  2878  			for shift := uint(0); ; shift += 7 {
  2879  				if shift >= 64 {
  2880  					return ErrIntOverflowGenerated
  2881  				}
  2882  				if iNdEx >= l {
  2883  					return io.ErrUnexpectedEOF
  2884  				}
  2885  				b := dAtA[iNdEx]
  2886  				iNdEx++
  2887  				stringLen |= uint64(b&0x7F) << shift
  2888  				if b < 0x80 {
  2889  					break
  2890  				}
  2891  			}
  2892  			intStringLen := int(stringLen)
  2893  			if intStringLen < 0 {
  2894  				return ErrInvalidLengthGenerated
  2895  			}
  2896  			postIndex := iNdEx + intStringLen
  2897  			if postIndex < 0 {
  2898  				return ErrInvalidLengthGenerated
  2899  			}
  2900  			if postIndex > l {
  2901  				return io.ErrUnexpectedEOF
  2902  			}
  2903  			m.InsecureEdgeTerminationPolicy = InsecureEdgeTerminationPolicyType(dAtA[iNdEx:postIndex])
  2904  			iNdEx = postIndex
  2905  		default:
  2906  			iNdEx = preIndex
  2907  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2908  			if err != nil {
  2909  				return err
  2910  			}
  2911  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2912  				return ErrInvalidLengthGenerated
  2913  			}
  2914  			if (iNdEx + skippy) > l {
  2915  				return io.ErrUnexpectedEOF
  2916  			}
  2917  			iNdEx += skippy
  2918  		}
  2919  	}
  2920  
  2921  	if iNdEx > l {
  2922  		return io.ErrUnexpectedEOF
  2923  	}
  2924  	return nil
  2925  }
  2926  func skipGenerated(dAtA []byte) (n int, err error) {
  2927  	l := len(dAtA)
  2928  	iNdEx := 0
  2929  	depth := 0
  2930  	for iNdEx < l {
  2931  		var wire uint64
  2932  		for shift := uint(0); ; shift += 7 {
  2933  			if shift >= 64 {
  2934  				return 0, ErrIntOverflowGenerated
  2935  			}
  2936  			if iNdEx >= l {
  2937  				return 0, io.ErrUnexpectedEOF
  2938  			}
  2939  			b := dAtA[iNdEx]
  2940  			iNdEx++
  2941  			wire |= (uint64(b) & 0x7F) << shift
  2942  			if b < 0x80 {
  2943  				break
  2944  			}
  2945  		}
  2946  		wireType := int(wire & 0x7)
  2947  		switch wireType {
  2948  		case 0:
  2949  			for shift := uint(0); ; shift += 7 {
  2950  				if shift >= 64 {
  2951  					return 0, ErrIntOverflowGenerated
  2952  				}
  2953  				if iNdEx >= l {
  2954  					return 0, io.ErrUnexpectedEOF
  2955  				}
  2956  				iNdEx++
  2957  				if dAtA[iNdEx-1] < 0x80 {
  2958  					break
  2959  				}
  2960  			}
  2961  		case 1:
  2962  			iNdEx += 8
  2963  		case 2:
  2964  			var length int
  2965  			for shift := uint(0); ; shift += 7 {
  2966  				if shift >= 64 {
  2967  					return 0, ErrIntOverflowGenerated
  2968  				}
  2969  				if iNdEx >= l {
  2970  					return 0, io.ErrUnexpectedEOF
  2971  				}
  2972  				b := dAtA[iNdEx]
  2973  				iNdEx++
  2974  				length |= (int(b) & 0x7F) << shift
  2975  				if b < 0x80 {
  2976  					break
  2977  				}
  2978  			}
  2979  			if length < 0 {
  2980  				return 0, ErrInvalidLengthGenerated
  2981  			}
  2982  			iNdEx += length
  2983  		case 3:
  2984  			depth++
  2985  		case 4:
  2986  			if depth == 0 {
  2987  				return 0, ErrUnexpectedEndOfGroupGenerated
  2988  			}
  2989  			depth--
  2990  		case 5:
  2991  			iNdEx += 4
  2992  		default:
  2993  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  2994  		}
  2995  		if iNdEx < 0 {
  2996  			return 0, ErrInvalidLengthGenerated
  2997  		}
  2998  		if depth == 0 {
  2999  			return iNdEx, nil
  3000  		}
  3001  	}
  3002  	return 0, io.ErrUnexpectedEOF
  3003  }
  3004  
  3005  var (
  3006  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  3007  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  3008  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  3009  )
  3010  

View as plain text