Source file src/k8s.io/api/discovery/v1/generated.pb.go

Documentation: k8s.io/api/discovery/v1

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

View as plain text