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

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

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

View as plain text