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

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

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

View as plain text