1/* 2Copyright The Kubernetes Authors. 3 4Licensed under the Apache License, Version 2.0 (the "License"); 5you may not use this file except in compliance with the License. 6You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10Unless required by applicable law or agreed to in writing, software 11distributed under the License is distributed on an "AS IS" BASIS, 12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13See the License for the specific language governing permissions and 14limitations under the License. 15*/ 16 17// Code generated by protoc-gen-gogo. DO NOT EDIT. 18// source: k8s.io/kubernetes/vendor/k8s.io/api/discovery/v1alpha1/generated.proto 19 20package v1alpha1 21 22import ( 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. 39var _ = proto.Marshal 40var _ = fmt.Errorf 41var _ = 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. 47const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 48 49func (m *Endpoint) Reset() { *m = Endpoint{} } 50func (*Endpoint) ProtoMessage() {} 51func (*Endpoint) Descriptor() ([]byte, []int) { 52 return fileDescriptor_772f83c5b34e07a5, []int{0} 53} 54func (m *Endpoint) XXX_Unmarshal(b []byte) error { 55 return m.Unmarshal(b) 56} 57func (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} 65func (m *Endpoint) XXX_Merge(src proto.Message) { 66 xxx_messageInfo_Endpoint.Merge(m, src) 67} 68func (m *Endpoint) XXX_Size() int { 69 return m.Size() 70} 71func (m *Endpoint) XXX_DiscardUnknown() { 72 xxx_messageInfo_Endpoint.DiscardUnknown(m) 73} 74 75var xxx_messageInfo_Endpoint proto.InternalMessageInfo 76 77func (m *EndpointConditions) Reset() { *m = EndpointConditions{} } 78func (*EndpointConditions) ProtoMessage() {} 79func (*EndpointConditions) Descriptor() ([]byte, []int) { 80 return fileDescriptor_772f83c5b34e07a5, []int{1} 81} 82func (m *EndpointConditions) XXX_Unmarshal(b []byte) error { 83 return m.Unmarshal(b) 84} 85func (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} 93func (m *EndpointConditions) XXX_Merge(src proto.Message) { 94 xxx_messageInfo_EndpointConditions.Merge(m, src) 95} 96func (m *EndpointConditions) XXX_Size() int { 97 return m.Size() 98} 99func (m *EndpointConditions) XXX_DiscardUnknown() { 100 xxx_messageInfo_EndpointConditions.DiscardUnknown(m) 101} 102 103var xxx_messageInfo_EndpointConditions proto.InternalMessageInfo 104 105func (m *EndpointPort) Reset() { *m = EndpointPort{} } 106func (*EndpointPort) ProtoMessage() {} 107func (*EndpointPort) Descriptor() ([]byte, []int) { 108 return fileDescriptor_772f83c5b34e07a5, []int{2} 109} 110func (m *EndpointPort) XXX_Unmarshal(b []byte) error { 111 return m.Unmarshal(b) 112} 113func (m *EndpointPort) 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} 121func (m *EndpointPort) XXX_Merge(src proto.Message) { 122 xxx_messageInfo_EndpointPort.Merge(m, src) 123} 124func (m *EndpointPort) XXX_Size() int { 125 return m.Size() 126} 127func (m *EndpointPort) XXX_DiscardUnknown() { 128 xxx_messageInfo_EndpointPort.DiscardUnknown(m) 129} 130 131var xxx_messageInfo_EndpointPort proto.InternalMessageInfo 132 133func (m *EndpointSlice) Reset() { *m = EndpointSlice{} } 134func (*EndpointSlice) ProtoMessage() {} 135func (*EndpointSlice) Descriptor() ([]byte, []int) { 136 return fileDescriptor_772f83c5b34e07a5, []int{3} 137} 138func (m *EndpointSlice) XXX_Unmarshal(b []byte) error { 139 return m.Unmarshal(b) 140} 141func (m *EndpointSlice) 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} 149func (m *EndpointSlice) XXX_Merge(src proto.Message) { 150 xxx_messageInfo_EndpointSlice.Merge(m, src) 151} 152func (m *EndpointSlice) XXX_Size() int { 153 return m.Size() 154} 155func (m *EndpointSlice) XXX_DiscardUnknown() { 156 xxx_messageInfo_EndpointSlice.DiscardUnknown(m) 157} 158 159var xxx_messageInfo_EndpointSlice proto.InternalMessageInfo 160 161func (m *EndpointSliceList) Reset() { *m = EndpointSliceList{} } 162func (*EndpointSliceList) ProtoMessage() {} 163func (*EndpointSliceList) Descriptor() ([]byte, []int) { 164 return fileDescriptor_772f83c5b34e07a5, []int{4} 165} 166func (m *EndpointSliceList) XXX_Unmarshal(b []byte) error { 167 return m.Unmarshal(b) 168} 169func (m *EndpointSliceList) 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} 177func (m *EndpointSliceList) XXX_Merge(src proto.Message) { 178 xxx_messageInfo_EndpointSliceList.Merge(m, src) 179} 180func (m *EndpointSliceList) XXX_Size() int { 181 return m.Size() 182} 183func (m *EndpointSliceList) XXX_DiscardUnknown() { 184 xxx_messageInfo_EndpointSliceList.DiscardUnknown(m) 185} 186 187var xxx_messageInfo_EndpointSliceList proto.InternalMessageInfo 188 189func init() { 190 proto.RegisterType((*Endpoint)(nil), "k8s.io.api.discovery.v1alpha1.Endpoint") 191 proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.discovery.v1alpha1.Endpoint.TopologyEntry") 192 proto.RegisterType((*EndpointConditions)(nil), "k8s.io.api.discovery.v1alpha1.EndpointConditions") 193 proto.RegisterType((*EndpointPort)(nil), "k8s.io.api.discovery.v1alpha1.EndpointPort") 194 proto.RegisterType((*EndpointSlice)(nil), "k8s.io.api.discovery.v1alpha1.EndpointSlice") 195 proto.RegisterType((*EndpointSliceList)(nil), "k8s.io.api.discovery.v1alpha1.EndpointSliceList") 196} 197 198func init() { 199 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/discovery/v1alpha1/generated.proto", fileDescriptor_772f83c5b34e07a5) 200} 201 202var fileDescriptor_772f83c5b34e07a5 = []byte{ 203 // 728 bytes of a gzipped FileDescriptorProto 204 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4b, 0x6f, 0xd3, 0x4a, 205 0x14, 0x8e, 0x9b, 0x5a, 0xb2, 0x27, 0x8d, 0xd4, 0x8e, 0xee, 0x22, 0xca, 0xbd, 0xd7, 0x8e, 0xc2, 206 0x82, 0x48, 0x85, 0x31, 0xa9, 0x28, 0xaa, 0x60, 0x43, 0x8d, 0xca, 0x43, 0xe2, 0x11, 0x86, 0x2e, 207 0x10, 0x62, 0xc1, 0xc4, 0x9e, 0x3a, 0x26, 0x89, 0xc7, 0xb2, 0x27, 0x91, 0xb2, 0xe3, 0x27, 0x20, 208 0xf1, 0x77, 0x58, 0xb2, 0xe8, 0xb2, 0xcb, 0xae, 0x0c, 0x35, 0xff, 0xa2, 0x2b, 0x34, 0xe3, 0x57, 209 0x4a, 0x78, 0x64, 0x37, 0xe7, 0x9b, 0xf3, 0x7d, 0xe7, 0x9c, 0x6f, 0xce, 0x80, 0x87, 0xe3, 0x83, 210 0x18, 0xf9, 0xcc, 0x1a, 0xcf, 0x86, 0x34, 0x0a, 0x28, 0xa7, 0xb1, 0x35, 0xa7, 0x81, 0xcb, 0x22, 211 0x2b, 0xbf, 0x20, 0xa1, 0x6f, 0xb9, 0x7e, 0xec, 0xb0, 0x39, 0x8d, 0x16, 0xd6, 0xbc, 0x4f, 0x26, 212 0xe1, 0x88, 0xf4, 0x2d, 0x8f, 0x06, 0x34, 0x22, 0x9c, 0xba, 0x28, 0x8c, 0x18, 0x67, 0xf0, 0xff, 213 0x2c, 0x1d, 0x91, 0xd0, 0x47, 0x65, 0x3a, 0x2a, 0xd2, 0xdb, 0x37, 0x3d, 0x9f, 0x8f, 0x66, 0x43, 214 0xe4, 0xb0, 0xa9, 0xe5, 0x31, 0x8f, 0x59, 0x92, 0x35, 0x9c, 0x9d, 0xc8, 0x48, 0x06, 0xf2, 0x94, 215 0xa9, 0xb5, 0xbb, 0x4b, 0xc5, 0x1d, 0x16, 0x51, 0x6b, 0xbe, 0x52, 0xb1, 0x7d, 0xbb, 0xca, 0x99, 216 0x12, 0x67, 0xe4, 0x07, 0xa2, 0xbf, 0x70, 0xec, 0x09, 0x20, 0xb6, 0xa6, 0x94, 0x93, 0x5f, 0xb1, 217 0xac, 0xdf, 0xb1, 0xa2, 0x59, 0xc0, 0xfd, 0x29, 0x5d, 0x21, 0xdc, 0xf9, 0x1b, 0x21, 0x76, 0x46, 218 0x74, 0x4a, 0x7e, 0xe6, 0x75, 0x3f, 0xd7, 0x81, 0x76, 0x14, 0xb8, 0x21, 0xf3, 0x03, 0x0e, 0x77, 219 0x81, 0x4e, 0x5c, 0x37, 0xa2, 0x71, 0x4c, 0xe3, 0x96, 0xd2, 0xa9, 0xf7, 0x74, 0xbb, 0x99, 0x26, 220 0xa6, 0x7e, 0x58, 0x80, 0xb8, 0xba, 0x87, 0x14, 0x00, 0x87, 0x05, 0xae, 0xcf, 0x7d, 0x16, 0xc4, 221 0xad, 0x8d, 0x8e, 0xd2, 0x6b, 0xec, 0xf5, 0xd1, 0x1f, 0xfd, 0x45, 0x45, 0xa5, 0x07, 0x25, 0xd1, 222 0x86, 0xa7, 0x89, 0x59, 0x4b, 0x13, 0x13, 0x54, 0x18, 0x5e, 0x12, 0x86, 0x3d, 0xa0, 0x8d, 0x58, 223 0xcc, 0x03, 0x32, 0xa5, 0xad, 0x7a, 0x47, 0xe9, 0xe9, 0xf6, 0x56, 0x9a, 0x98, 0xda, 0xe3, 0x1c, 224 0xc3, 0xe5, 0x2d, 0x1c, 0x00, 0x9d, 0x93, 0xc8, 0xa3, 0x1c, 0xd3, 0x93, 0xd6, 0xa6, 0xec, 0xe7, 225 0xda, 0x72, 0x3f, 0xe2, 0x85, 0xd0, 0xbc, 0x8f, 0x5e, 0x0c, 0xdf, 0x53, 0x47, 0x24, 0xd1, 0x88, 226 0x06, 0x0e, 0xcd, 0x46, 0x3c, 0x2e, 0x98, 0xb8, 0x12, 0x81, 0x0e, 0xd0, 0x38, 0x0b, 0xd9, 0x84, 227 0x79, 0x8b, 0x96, 0xda, 0xa9, 0xf7, 0x1a, 0x7b, 0xfb, 0x6b, 0x0e, 0x88, 0x8e, 0x73, 0xde, 0x51, 228 0xc0, 0xa3, 0x85, 0xbd, 0x9d, 0x0f, 0xa9, 0x15, 0x30, 0x2e, 0x85, 0xdb, 0xf7, 0x40, 0xf3, 0x4a, 229 0x32, 0xdc, 0x06, 0xf5, 0x31, 0x5d, 0xb4, 0x14, 0x31, 0x2c, 0x16, 0x47, 0xf8, 0x0f, 0x50, 0xe7, 230 0x64, 0x32, 0xa3, 0xd2, 0x65, 0x1d, 0x67, 0xc1, 0xdd, 0x8d, 0x03, 0xa5, 0xbb, 0x0f, 0xe0, 0xaa, 231 0xa7, 0xd0, 0x04, 0x6a, 0x44, 0x89, 0x9b, 0x69, 0x68, 0xb6, 0x9e, 0x26, 0xa6, 0x8a, 0x05, 0x80, 232 0x33, 0xbc, 0xfb, 0x49, 0x01, 0x5b, 0x05, 0x6f, 0xc0, 0x22, 0x0e, 0xff, 0x03, 0x9b, 0xd2, 0x61, 233 0x59, 0xd4, 0xd6, 0xd2, 0xc4, 0xdc, 0x7c, 0x2e, 0xdc, 0x95, 0x28, 0x7c, 0x04, 0x34, 0xb9, 0x2d, 234 0x0e, 0x9b, 0x64, 0x2d, 0xd8, 0xbb, 0x62, 0x98, 0x41, 0x8e, 0x5d, 0x26, 0xe6, 0xbf, 0xab, 0x3f, 235 0x01, 0x15, 0xd7, 0xb8, 0x24, 0x8b, 0x32, 0x21, 0x8b, 0xb8, 0x7c, 0x48, 0x35, 0x2b, 0x23, 0xca, 236 0x63, 0x89, 0x76, 0xbf, 0x6e, 0x80, 0x66, 0xd1, 0xd5, 0xab, 0x89, 0xef, 0x50, 0xf8, 0x0e, 0x68, 237 0xe2, 0x87, 0xb8, 0x84, 0x13, 0xd9, 0x5a, 0x63, 0xef, 0xd6, 0xd2, 0x03, 0x94, 0x8b, 0x8e, 0xc2, 238 0xb1, 0x27, 0x80, 0x18, 0x89, 0xec, 0xea, 0x8d, 0x9f, 0x51, 0x4e, 0xaa, 0x05, 0xab, 0x30, 0x5c, 239 0xaa, 0xc2, 0xfb, 0xa0, 0x91, 0xaf, 0xf4, 0xf1, 0x22, 0xa4, 0x72, 0x6d, 0x74, 0xdb, 0x48, 0x13, 240 0xb3, 0x71, 0x58, 0xc1, 0x97, 0x57, 0x43, 0xbc, 0x4c, 0x81, 0xaf, 0x81, 0x4e, 0xf3, 0xa6, 0xc5, 241 0x37, 0x10, 0x5b, 0x72, 0x7d, 0xcd, 0x2d, 0xb1, 0x77, 0xf2, 0xde, 0xf4, 0x02, 0x89, 0x71, 0x25, 242 0x06, 0x07, 0x40, 0x15, 0xbe, 0xc4, 0xad, 0xba, 0x54, 0xdd, 0x5d, 0x53, 0x55, 0x38, 0x6a, 0x37, 243 0x73, 0x65, 0x55, 0x44, 0x31, 0xce, 0x84, 0xba, 0x5f, 0x14, 0xb0, 0x73, 0xc5, 0xe1, 0xa7, 0x7e, 244 0xcc, 0xe1, 0xdb, 0x15, 0x97, 0xd1, 0x7a, 0x2e, 0x0b, 0xb6, 0xf4, 0xb8, 0xdc, 0xef, 0x02, 0x59, 245 0x72, 0xf8, 0x25, 0x50, 0x7d, 0x4e, 0xa7, 0x85, 0x37, 0x37, 0xd6, 0x9c, 0x42, 0xb6, 0x57, 0x8d, 246 0xf1, 0x44, 0x48, 0xe0, 0x4c, 0xc9, 0x46, 0xa7, 0x17, 0x46, 0xed, 0xec, 0xc2, 0xa8, 0x9d, 0x5f, 247 0x18, 0xb5, 0x0f, 0xa9, 0xa1, 0x9c, 0xa6, 0x86, 0x72, 0x96, 0x1a, 0xca, 0x79, 0x6a, 0x28, 0xdf, 248 0x52, 0x43, 0xf9, 0xf8, 0xdd, 0xa8, 0xbd, 0xd1, 0x0a, 0xcd, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 249 0x04, 0x9d, 0x1a, 0x33, 0x3e, 0x06, 0x00, 0x00, 250} 251 252func (m *Endpoint) Marshal() (dAtA []byte, err error) { 253 size := m.Size() 254 dAtA = make([]byte, size) 255 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 256 if err != nil { 257 return nil, err 258 } 259 return dAtA[:n], nil 260} 261 262func (m *Endpoint) MarshalTo(dAtA []byte) (int, error) { 263 size := m.Size() 264 return m.MarshalToSizedBuffer(dAtA[:size]) 265} 266 267func (m *Endpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) { 268 i := len(dAtA) 269 _ = i 270 var l int 271 _ = l 272 if len(m.Topology) > 0 { 273 keysForTopology := make([]string, 0, len(m.Topology)) 274 for k := range m.Topology { 275 keysForTopology = append(keysForTopology, string(k)) 276 } 277 github_com_gogo_protobuf_sortkeys.Strings(keysForTopology) 278 for iNdEx := len(keysForTopology) - 1; iNdEx >= 0; iNdEx-- { 279 v := m.Topology[string(keysForTopology[iNdEx])] 280 baseI := i 281 i -= len(v) 282 copy(dAtA[i:], v) 283 i = encodeVarintGenerated(dAtA, i, uint64(len(v))) 284 i-- 285 dAtA[i] = 0x12 286 i -= len(keysForTopology[iNdEx]) 287 copy(dAtA[i:], keysForTopology[iNdEx]) 288 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForTopology[iNdEx]))) 289 i-- 290 dAtA[i] = 0xa 291 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) 292 i-- 293 dAtA[i] = 0x2a 294 } 295 } 296 if m.TargetRef != nil { 297 { 298 size, err := m.TargetRef.MarshalToSizedBuffer(dAtA[:i]) 299 if err != nil { 300 return 0, err 301 } 302 i -= size 303 i = encodeVarintGenerated(dAtA, i, uint64(size)) 304 } 305 i-- 306 dAtA[i] = 0x22 307 } 308 if m.Hostname != nil { 309 i -= len(*m.Hostname) 310 copy(dAtA[i:], *m.Hostname) 311 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Hostname))) 312 i-- 313 dAtA[i] = 0x1a 314 } 315 { 316 size, err := m.Conditions.MarshalToSizedBuffer(dAtA[:i]) 317 if err != nil { 318 return 0, err 319 } 320 i -= size 321 i = encodeVarintGenerated(dAtA, i, uint64(size)) 322 } 323 i-- 324 dAtA[i] = 0x12 325 if len(m.Addresses) > 0 { 326 for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { 327 i -= len(m.Addresses[iNdEx]) 328 copy(dAtA[i:], m.Addresses[iNdEx]) 329 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Addresses[iNdEx]))) 330 i-- 331 dAtA[i] = 0xa 332 } 333 } 334 return len(dAtA) - i, nil 335} 336 337func (m *EndpointConditions) Marshal() (dAtA []byte, err error) { 338 size := m.Size() 339 dAtA = make([]byte, size) 340 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 341 if err != nil { 342 return nil, err 343 } 344 return dAtA[:n], nil 345} 346 347func (m *EndpointConditions) MarshalTo(dAtA []byte) (int, error) { 348 size := m.Size() 349 return m.MarshalToSizedBuffer(dAtA[:size]) 350} 351 352func (m *EndpointConditions) MarshalToSizedBuffer(dAtA []byte) (int, error) { 353 i := len(dAtA) 354 _ = i 355 var l int 356 _ = l 357 if m.Ready != nil { 358 i-- 359 if *m.Ready { 360 dAtA[i] = 1 361 } else { 362 dAtA[i] = 0 363 } 364 i-- 365 dAtA[i] = 0x8 366 } 367 return len(dAtA) - i, nil 368} 369 370func (m *EndpointPort) Marshal() (dAtA []byte, err error) { 371 size := m.Size() 372 dAtA = make([]byte, size) 373 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 374 if err != nil { 375 return nil, err 376 } 377 return dAtA[:n], nil 378} 379 380func (m *EndpointPort) MarshalTo(dAtA []byte) (int, error) { 381 size := m.Size() 382 return m.MarshalToSizedBuffer(dAtA[:size]) 383} 384 385func (m *EndpointPort) MarshalToSizedBuffer(dAtA []byte) (int, error) { 386 i := len(dAtA) 387 _ = i 388 var l int 389 _ = l 390 if m.Port != nil { 391 i = encodeVarintGenerated(dAtA, i, uint64(*m.Port)) 392 i-- 393 dAtA[i] = 0x18 394 } 395 if m.Protocol != nil { 396 i -= len(*m.Protocol) 397 copy(dAtA[i:], *m.Protocol) 398 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol))) 399 i-- 400 dAtA[i] = 0x12 401 } 402 if m.Name != nil { 403 i -= len(*m.Name) 404 copy(dAtA[i:], *m.Name) 405 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Name))) 406 i-- 407 dAtA[i] = 0xa 408 } 409 return len(dAtA) - i, nil 410} 411 412func (m *EndpointSlice) Marshal() (dAtA []byte, err error) { 413 size := m.Size() 414 dAtA = make([]byte, size) 415 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 416 if err != nil { 417 return nil, err 418 } 419 return dAtA[:n], nil 420} 421 422func (m *EndpointSlice) MarshalTo(dAtA []byte) (int, error) { 423 size := m.Size() 424 return m.MarshalToSizedBuffer(dAtA[:size]) 425} 426 427func (m *EndpointSlice) MarshalToSizedBuffer(dAtA []byte) (int, error) { 428 i := len(dAtA) 429 _ = i 430 var l int 431 _ = l 432 if m.AddressType != nil { 433 i -= len(*m.AddressType) 434 copy(dAtA[i:], *m.AddressType) 435 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.AddressType))) 436 i-- 437 dAtA[i] = 0x22 438 } 439 if len(m.Ports) > 0 { 440 for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- { 441 { 442 size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 443 if err != nil { 444 return 0, err 445 } 446 i -= size 447 i = encodeVarintGenerated(dAtA, i, uint64(size)) 448 } 449 i-- 450 dAtA[i] = 0x1a 451 } 452 } 453 if len(m.Endpoints) > 0 { 454 for iNdEx := len(m.Endpoints) - 1; iNdEx >= 0; iNdEx-- { 455 { 456 size, err := m.Endpoints[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 457 if err != nil { 458 return 0, err 459 } 460 i -= size 461 i = encodeVarintGenerated(dAtA, i, uint64(size)) 462 } 463 i-- 464 dAtA[i] = 0x12 465 } 466 } 467 { 468 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) 469 if err != nil { 470 return 0, err 471 } 472 i -= size 473 i = encodeVarintGenerated(dAtA, i, uint64(size)) 474 } 475 i-- 476 dAtA[i] = 0xa 477 return len(dAtA) - i, nil 478} 479 480func (m *EndpointSliceList) Marshal() (dAtA []byte, err error) { 481 size := m.Size() 482 dAtA = make([]byte, size) 483 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 484 if err != nil { 485 return nil, err 486 } 487 return dAtA[:n], nil 488} 489 490func (m *EndpointSliceList) MarshalTo(dAtA []byte) (int, error) { 491 size := m.Size() 492 return m.MarshalToSizedBuffer(dAtA[:size]) 493} 494 495func (m *EndpointSliceList) MarshalToSizedBuffer(dAtA []byte) (int, error) { 496 i := len(dAtA) 497 _ = i 498 var l int 499 _ = l 500 if len(m.Items) > 0 { 501 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { 502 { 503 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 504 if err != nil { 505 return 0, err 506 } 507 i -= size 508 i = encodeVarintGenerated(dAtA, i, uint64(size)) 509 } 510 i-- 511 dAtA[i] = 0x12 512 } 513 } 514 { 515 size, err := m.ListMeta.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 527func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { 528 offset -= sovGenerated(v) 529 base := offset 530 for v >= 1<<7 { 531 dAtA[offset] = uint8(v&0x7f | 0x80) 532 v >>= 7 533 offset++ 534 } 535 dAtA[offset] = uint8(v) 536 return base 537} 538func (m *Endpoint) Size() (n int) { 539 if m == nil { 540 return 0 541 } 542 var l int 543 _ = l 544 if len(m.Addresses) > 0 { 545 for _, s := range m.Addresses { 546 l = len(s) 547 n += 1 + l + sovGenerated(uint64(l)) 548 } 549 } 550 l = m.Conditions.Size() 551 n += 1 + l + sovGenerated(uint64(l)) 552 if m.Hostname != nil { 553 l = len(*m.Hostname) 554 n += 1 + l + sovGenerated(uint64(l)) 555 } 556 if m.TargetRef != nil { 557 l = m.TargetRef.Size() 558 n += 1 + l + sovGenerated(uint64(l)) 559 } 560 if len(m.Topology) > 0 { 561 for k, v := range m.Topology { 562 _ = k 563 _ = v 564 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 565 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) 566 } 567 } 568 return n 569} 570 571func (m *EndpointConditions) Size() (n int) { 572 if m == nil { 573 return 0 574 } 575 var l int 576 _ = l 577 if m.Ready != nil { 578 n += 2 579 } 580 return n 581} 582 583func (m *EndpointPort) Size() (n int) { 584 if m == nil { 585 return 0 586 } 587 var l int 588 _ = l 589 if m.Name != nil { 590 l = len(*m.Name) 591 n += 1 + l + sovGenerated(uint64(l)) 592 } 593 if m.Protocol != nil { 594 l = len(*m.Protocol) 595 n += 1 + l + sovGenerated(uint64(l)) 596 } 597 if m.Port != nil { 598 n += 1 + sovGenerated(uint64(*m.Port)) 599 } 600 return n 601} 602 603func (m *EndpointSlice) Size() (n int) { 604 if m == nil { 605 return 0 606 } 607 var l int 608 _ = l 609 l = m.ObjectMeta.Size() 610 n += 1 + l + sovGenerated(uint64(l)) 611 if len(m.Endpoints) > 0 { 612 for _, e := range m.Endpoints { 613 l = e.Size() 614 n += 1 + l + sovGenerated(uint64(l)) 615 } 616 } 617 if len(m.Ports) > 0 { 618 for _, e := range m.Ports { 619 l = e.Size() 620 n += 1 + l + sovGenerated(uint64(l)) 621 } 622 } 623 if m.AddressType != nil { 624 l = len(*m.AddressType) 625 n += 1 + l + sovGenerated(uint64(l)) 626 } 627 return n 628} 629 630func (m *EndpointSliceList) Size() (n int) { 631 if m == nil { 632 return 0 633 } 634 var l int 635 _ = l 636 l = m.ListMeta.Size() 637 n += 1 + l + sovGenerated(uint64(l)) 638 if len(m.Items) > 0 { 639 for _, e := range m.Items { 640 l = e.Size() 641 n += 1 + l + sovGenerated(uint64(l)) 642 } 643 } 644 return n 645} 646 647func sovGenerated(x uint64) (n int) { 648 return (math_bits.Len64(x|1) + 6) / 7 649} 650func sozGenerated(x uint64) (n int) { 651 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 652} 653func (this *Endpoint) String() string { 654 if this == nil { 655 return "nil" 656 } 657 keysForTopology := make([]string, 0, len(this.Topology)) 658 for k := range this.Topology { 659 keysForTopology = append(keysForTopology, k) 660 } 661 github_com_gogo_protobuf_sortkeys.Strings(keysForTopology) 662 mapStringForTopology := "map[string]string{" 663 for _, k := range keysForTopology { 664 mapStringForTopology += fmt.Sprintf("%v: %v,", k, this.Topology[k]) 665 } 666 mapStringForTopology += "}" 667 s := strings.Join([]string{`&Endpoint{`, 668 `Addresses:` + fmt.Sprintf("%v", this.Addresses) + `,`, 669 `Conditions:` + strings.Replace(strings.Replace(this.Conditions.String(), "EndpointConditions", "EndpointConditions", 1), `&`, ``, 1) + `,`, 670 `Hostname:` + valueToStringGenerated(this.Hostname) + `,`, 671 `TargetRef:` + strings.Replace(fmt.Sprintf("%v", this.TargetRef), "ObjectReference", "v1.ObjectReference", 1) + `,`, 672 `Topology:` + mapStringForTopology + `,`, 673 `}`, 674 }, "") 675 return s 676} 677func (this *EndpointConditions) String() string { 678 if this == nil { 679 return "nil" 680 } 681 s := strings.Join([]string{`&EndpointConditions{`, 682 `Ready:` + valueToStringGenerated(this.Ready) + `,`, 683 `}`, 684 }, "") 685 return s 686} 687func (this *EndpointPort) String() string { 688 if this == nil { 689 return "nil" 690 } 691 s := strings.Join([]string{`&EndpointPort{`, 692 `Name:` + valueToStringGenerated(this.Name) + `,`, 693 `Protocol:` + valueToStringGenerated(this.Protocol) + `,`, 694 `Port:` + valueToStringGenerated(this.Port) + `,`, 695 `}`, 696 }, "") 697 return s 698} 699func (this *EndpointSlice) String() string { 700 if this == nil { 701 return "nil" 702 } 703 repeatedStringForEndpoints := "[]Endpoint{" 704 for _, f := range this.Endpoints { 705 repeatedStringForEndpoints += strings.Replace(strings.Replace(f.String(), "Endpoint", "Endpoint", 1), `&`, ``, 1) + "," 706 } 707 repeatedStringForEndpoints += "}" 708 repeatedStringForPorts := "[]EndpointPort{" 709 for _, f := range this.Ports { 710 repeatedStringForPorts += strings.Replace(strings.Replace(f.String(), "EndpointPort", "EndpointPort", 1), `&`, ``, 1) + "," 711 } 712 repeatedStringForPorts += "}" 713 s := strings.Join([]string{`&EndpointSlice{`, 714 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v11.ObjectMeta", 1), `&`, ``, 1) + `,`, 715 `Endpoints:` + repeatedStringForEndpoints + `,`, 716 `Ports:` + repeatedStringForPorts + `,`, 717 `AddressType:` + valueToStringGenerated(this.AddressType) + `,`, 718 `}`, 719 }, "") 720 return s 721} 722func (this *EndpointSliceList) String() string { 723 if this == nil { 724 return "nil" 725 } 726 repeatedStringForItems := "[]EndpointSlice{" 727 for _, f := range this.Items { 728 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "EndpointSlice", "EndpointSlice", 1), `&`, ``, 1) + "," 729 } 730 repeatedStringForItems += "}" 731 s := strings.Join([]string{`&EndpointSliceList{`, 732 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v11.ListMeta", 1), `&`, ``, 1) + `,`, 733 `Items:` + repeatedStringForItems + `,`, 734 `}`, 735 }, "") 736 return s 737} 738func valueToStringGenerated(v interface{}) string { 739 rv := reflect.ValueOf(v) 740 if rv.IsNil() { 741 return "nil" 742 } 743 pv := reflect.Indirect(rv).Interface() 744 return fmt.Sprintf("*%v", pv) 745} 746func (m *Endpoint) Unmarshal(dAtA []byte) error { 747 l := len(dAtA) 748 iNdEx := 0 749 for iNdEx < l { 750 preIndex := iNdEx 751 var wire uint64 752 for shift := uint(0); ; shift += 7 { 753 if shift >= 64 { 754 return ErrIntOverflowGenerated 755 } 756 if iNdEx >= l { 757 return io.ErrUnexpectedEOF 758 } 759 b := dAtA[iNdEx] 760 iNdEx++ 761 wire |= uint64(b&0x7F) << shift 762 if b < 0x80 { 763 break 764 } 765 } 766 fieldNum := int32(wire >> 3) 767 wireType := int(wire & 0x7) 768 if wireType == 4 { 769 return fmt.Errorf("proto: Endpoint: wiretype end group for non-group") 770 } 771 if fieldNum <= 0 { 772 return fmt.Errorf("proto: Endpoint: illegal tag %d (wire type %d)", fieldNum, wire) 773 } 774 switch fieldNum { 775 case 1: 776 if wireType != 2 { 777 return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType) 778 } 779 var stringLen uint64 780 for shift := uint(0); ; shift += 7 { 781 if shift >= 64 { 782 return ErrIntOverflowGenerated 783 } 784 if iNdEx >= l { 785 return io.ErrUnexpectedEOF 786 } 787 b := dAtA[iNdEx] 788 iNdEx++ 789 stringLen |= uint64(b&0x7F) << shift 790 if b < 0x80 { 791 break 792 } 793 } 794 intStringLen := int(stringLen) 795 if intStringLen < 0 { 796 return ErrInvalidLengthGenerated 797 } 798 postIndex := iNdEx + intStringLen 799 if postIndex < 0 { 800 return ErrInvalidLengthGenerated 801 } 802 if postIndex > l { 803 return io.ErrUnexpectedEOF 804 } 805 m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex])) 806 iNdEx = postIndex 807 case 2: 808 if wireType != 2 { 809 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) 810 } 811 var msglen int 812 for shift := uint(0); ; shift += 7 { 813 if shift >= 64 { 814 return ErrIntOverflowGenerated 815 } 816 if iNdEx >= l { 817 return io.ErrUnexpectedEOF 818 } 819 b := dAtA[iNdEx] 820 iNdEx++ 821 msglen |= int(b&0x7F) << shift 822 if b < 0x80 { 823 break 824 } 825 } 826 if msglen < 0 { 827 return ErrInvalidLengthGenerated 828 } 829 postIndex := iNdEx + msglen 830 if postIndex < 0 { 831 return ErrInvalidLengthGenerated 832 } 833 if postIndex > l { 834 return io.ErrUnexpectedEOF 835 } 836 if err := m.Conditions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 837 return err 838 } 839 iNdEx = postIndex 840 case 3: 841 if wireType != 2 { 842 return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) 843 } 844 var stringLen uint64 845 for shift := uint(0); ; shift += 7 { 846 if shift >= 64 { 847 return ErrIntOverflowGenerated 848 } 849 if iNdEx >= l { 850 return io.ErrUnexpectedEOF 851 } 852 b := dAtA[iNdEx] 853 iNdEx++ 854 stringLen |= uint64(b&0x7F) << shift 855 if b < 0x80 { 856 break 857 } 858 } 859 intStringLen := int(stringLen) 860 if intStringLen < 0 { 861 return ErrInvalidLengthGenerated 862 } 863 postIndex := iNdEx + intStringLen 864 if postIndex < 0 { 865 return ErrInvalidLengthGenerated 866 } 867 if postIndex > l { 868 return io.ErrUnexpectedEOF 869 } 870 s := string(dAtA[iNdEx:postIndex]) 871 m.Hostname = &s 872 iNdEx = postIndex 873 case 4: 874 if wireType != 2 { 875 return fmt.Errorf("proto: wrong wireType = %d for field TargetRef", wireType) 876 } 877 var msglen int 878 for shift := uint(0); ; shift += 7 { 879 if shift >= 64 { 880 return ErrIntOverflowGenerated 881 } 882 if iNdEx >= l { 883 return io.ErrUnexpectedEOF 884 } 885 b := dAtA[iNdEx] 886 iNdEx++ 887 msglen |= int(b&0x7F) << shift 888 if b < 0x80 { 889 break 890 } 891 } 892 if msglen < 0 { 893 return ErrInvalidLengthGenerated 894 } 895 postIndex := iNdEx + msglen 896 if postIndex < 0 { 897 return ErrInvalidLengthGenerated 898 } 899 if postIndex > l { 900 return io.ErrUnexpectedEOF 901 } 902 if m.TargetRef == nil { 903 m.TargetRef = &v1.ObjectReference{} 904 } 905 if err := m.TargetRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 906 return err 907 } 908 iNdEx = postIndex 909 case 5: 910 if wireType != 2 { 911 return fmt.Errorf("proto: wrong wireType = %d for field Topology", wireType) 912 } 913 var msglen int 914 for shift := uint(0); ; shift += 7 { 915 if shift >= 64 { 916 return ErrIntOverflowGenerated 917 } 918 if iNdEx >= l { 919 return io.ErrUnexpectedEOF 920 } 921 b := dAtA[iNdEx] 922 iNdEx++ 923 msglen |= int(b&0x7F) << shift 924 if b < 0x80 { 925 break 926 } 927 } 928 if msglen < 0 { 929 return ErrInvalidLengthGenerated 930 } 931 postIndex := iNdEx + msglen 932 if postIndex < 0 { 933 return ErrInvalidLengthGenerated 934 } 935 if postIndex > l { 936 return io.ErrUnexpectedEOF 937 } 938 if m.Topology == nil { 939 m.Topology = make(map[string]string) 940 } 941 var mapkey string 942 var mapvalue string 943 for iNdEx < postIndex { 944 entryPreIndex := iNdEx 945 var wire uint64 946 for shift := uint(0); ; shift += 7 { 947 if shift >= 64 { 948 return ErrIntOverflowGenerated 949 } 950 if iNdEx >= l { 951 return io.ErrUnexpectedEOF 952 } 953 b := dAtA[iNdEx] 954 iNdEx++ 955 wire |= uint64(b&0x7F) << shift 956 if b < 0x80 { 957 break 958 } 959 } 960 fieldNum := int32(wire >> 3) 961 if fieldNum == 1 { 962 var stringLenmapkey uint64 963 for shift := uint(0); ; shift += 7 { 964 if shift >= 64 { 965 return ErrIntOverflowGenerated 966 } 967 if iNdEx >= l { 968 return io.ErrUnexpectedEOF 969 } 970 b := dAtA[iNdEx] 971 iNdEx++ 972 stringLenmapkey |= uint64(b&0x7F) << shift 973 if b < 0x80 { 974 break 975 } 976 } 977 intStringLenmapkey := int(stringLenmapkey) 978 if intStringLenmapkey < 0 { 979 return ErrInvalidLengthGenerated 980 } 981 postStringIndexmapkey := iNdEx + intStringLenmapkey 982 if postStringIndexmapkey < 0 { 983 return ErrInvalidLengthGenerated 984 } 985 if postStringIndexmapkey > l { 986 return io.ErrUnexpectedEOF 987 } 988 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 989 iNdEx = postStringIndexmapkey 990 } else if fieldNum == 2 { 991 var stringLenmapvalue uint64 992 for shift := uint(0); ; shift += 7 { 993 if shift >= 64 { 994 return ErrIntOverflowGenerated 995 } 996 if iNdEx >= l { 997 return io.ErrUnexpectedEOF 998 } 999 b := dAtA[iNdEx] 1000 iNdEx++ 1001 stringLenmapvalue |= uint64(b&0x7F) << shift 1002 if b < 0x80 { 1003 break 1004 } 1005 } 1006 intStringLenmapvalue := int(stringLenmapvalue) 1007 if intStringLenmapvalue < 0 { 1008 return ErrInvalidLengthGenerated 1009 } 1010 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 1011 if postStringIndexmapvalue < 0 { 1012 return ErrInvalidLengthGenerated 1013 } 1014 if postStringIndexmapvalue > l { 1015 return io.ErrUnexpectedEOF 1016 } 1017 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 1018 iNdEx = postStringIndexmapvalue 1019 } else { 1020 iNdEx = entryPreIndex 1021 skippy, err := skipGenerated(dAtA[iNdEx:]) 1022 if err != nil { 1023 return err 1024 } 1025 if skippy < 0 { 1026 return ErrInvalidLengthGenerated 1027 } 1028 if (iNdEx + skippy) > postIndex { 1029 return io.ErrUnexpectedEOF 1030 } 1031 iNdEx += skippy 1032 } 1033 } 1034 m.Topology[mapkey] = mapvalue 1035 iNdEx = postIndex 1036 default: 1037 iNdEx = preIndex 1038 skippy, err := skipGenerated(dAtA[iNdEx:]) 1039 if err != nil { 1040 return err 1041 } 1042 if skippy < 0 { 1043 return ErrInvalidLengthGenerated 1044 } 1045 if (iNdEx + skippy) < 0 { 1046 return ErrInvalidLengthGenerated 1047 } 1048 if (iNdEx + skippy) > l { 1049 return io.ErrUnexpectedEOF 1050 } 1051 iNdEx += skippy 1052 } 1053 } 1054 1055 if iNdEx > l { 1056 return io.ErrUnexpectedEOF 1057 } 1058 return nil 1059} 1060func (m *EndpointConditions) Unmarshal(dAtA []byte) error { 1061 l := len(dAtA) 1062 iNdEx := 0 1063 for iNdEx < l { 1064 preIndex := iNdEx 1065 var wire uint64 1066 for shift := uint(0); ; shift += 7 { 1067 if shift >= 64 { 1068 return ErrIntOverflowGenerated 1069 } 1070 if iNdEx >= l { 1071 return io.ErrUnexpectedEOF 1072 } 1073 b := dAtA[iNdEx] 1074 iNdEx++ 1075 wire |= uint64(b&0x7F) << shift 1076 if b < 0x80 { 1077 break 1078 } 1079 } 1080 fieldNum := int32(wire >> 3) 1081 wireType := int(wire & 0x7) 1082 if wireType == 4 { 1083 return fmt.Errorf("proto: EndpointConditions: wiretype end group for non-group") 1084 } 1085 if fieldNum <= 0 { 1086 return fmt.Errorf("proto: EndpointConditions: illegal tag %d (wire type %d)", fieldNum, wire) 1087 } 1088 switch fieldNum { 1089 case 1: 1090 if wireType != 0 { 1091 return fmt.Errorf("proto: wrong wireType = %d for field Ready", wireType) 1092 } 1093 var v int 1094 for shift := uint(0); ; shift += 7 { 1095 if shift >= 64 { 1096 return ErrIntOverflowGenerated 1097 } 1098 if iNdEx >= l { 1099 return io.ErrUnexpectedEOF 1100 } 1101 b := dAtA[iNdEx] 1102 iNdEx++ 1103 v |= int(b&0x7F) << shift 1104 if b < 0x80 { 1105 break 1106 } 1107 } 1108 b := bool(v != 0) 1109 m.Ready = &b 1110 default: 1111 iNdEx = preIndex 1112 skippy, err := skipGenerated(dAtA[iNdEx:]) 1113 if err != nil { 1114 return err 1115 } 1116 if skippy < 0 { 1117 return ErrInvalidLengthGenerated 1118 } 1119 if (iNdEx + skippy) < 0 { 1120 return ErrInvalidLengthGenerated 1121 } 1122 if (iNdEx + skippy) > l { 1123 return io.ErrUnexpectedEOF 1124 } 1125 iNdEx += skippy 1126 } 1127 } 1128 1129 if iNdEx > l { 1130 return io.ErrUnexpectedEOF 1131 } 1132 return nil 1133} 1134func (m *EndpointPort) Unmarshal(dAtA []byte) error { 1135 l := len(dAtA) 1136 iNdEx := 0 1137 for iNdEx < l { 1138 preIndex := iNdEx 1139 var wire uint64 1140 for shift := uint(0); ; shift += 7 { 1141 if shift >= 64 { 1142 return ErrIntOverflowGenerated 1143 } 1144 if iNdEx >= l { 1145 return io.ErrUnexpectedEOF 1146 } 1147 b := dAtA[iNdEx] 1148 iNdEx++ 1149 wire |= uint64(b&0x7F) << shift 1150 if b < 0x80 { 1151 break 1152 } 1153 } 1154 fieldNum := int32(wire >> 3) 1155 wireType := int(wire & 0x7) 1156 if wireType == 4 { 1157 return fmt.Errorf("proto: EndpointPort: wiretype end group for non-group") 1158 } 1159 if fieldNum <= 0 { 1160 return fmt.Errorf("proto: EndpointPort: illegal tag %d (wire type %d)", fieldNum, wire) 1161 } 1162 switch fieldNum { 1163 case 1: 1164 if wireType != 2 { 1165 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 1166 } 1167 var stringLen uint64 1168 for shift := uint(0); ; shift += 7 { 1169 if shift >= 64 { 1170 return ErrIntOverflowGenerated 1171 } 1172 if iNdEx >= l { 1173 return io.ErrUnexpectedEOF 1174 } 1175 b := dAtA[iNdEx] 1176 iNdEx++ 1177 stringLen |= uint64(b&0x7F) << shift 1178 if b < 0x80 { 1179 break 1180 } 1181 } 1182 intStringLen := int(stringLen) 1183 if intStringLen < 0 { 1184 return ErrInvalidLengthGenerated 1185 } 1186 postIndex := iNdEx + intStringLen 1187 if postIndex < 0 { 1188 return ErrInvalidLengthGenerated 1189 } 1190 if postIndex > l { 1191 return io.ErrUnexpectedEOF 1192 } 1193 s := string(dAtA[iNdEx:postIndex]) 1194 m.Name = &s 1195 iNdEx = postIndex 1196 case 2: 1197 if wireType != 2 { 1198 return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) 1199 } 1200 var stringLen uint64 1201 for shift := uint(0); ; shift += 7 { 1202 if shift >= 64 { 1203 return ErrIntOverflowGenerated 1204 } 1205 if iNdEx >= l { 1206 return io.ErrUnexpectedEOF 1207 } 1208 b := dAtA[iNdEx] 1209 iNdEx++ 1210 stringLen |= uint64(b&0x7F) << shift 1211 if b < 0x80 { 1212 break 1213 } 1214 } 1215 intStringLen := int(stringLen) 1216 if intStringLen < 0 { 1217 return ErrInvalidLengthGenerated 1218 } 1219 postIndex := iNdEx + intStringLen 1220 if postIndex < 0 { 1221 return ErrInvalidLengthGenerated 1222 } 1223 if postIndex > l { 1224 return io.ErrUnexpectedEOF 1225 } 1226 s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex]) 1227 m.Protocol = &s 1228 iNdEx = postIndex 1229 case 3: 1230 if wireType != 0 { 1231 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) 1232 } 1233 var v int32 1234 for shift := uint(0); ; shift += 7 { 1235 if shift >= 64 { 1236 return ErrIntOverflowGenerated 1237 } 1238 if iNdEx >= l { 1239 return io.ErrUnexpectedEOF 1240 } 1241 b := dAtA[iNdEx] 1242 iNdEx++ 1243 v |= int32(b&0x7F) << shift 1244 if b < 0x80 { 1245 break 1246 } 1247 } 1248 m.Port = &v 1249 default: 1250 iNdEx = preIndex 1251 skippy, err := skipGenerated(dAtA[iNdEx:]) 1252 if err != nil { 1253 return err 1254 } 1255 if skippy < 0 { 1256 return ErrInvalidLengthGenerated 1257 } 1258 if (iNdEx + skippy) < 0 { 1259 return ErrInvalidLengthGenerated 1260 } 1261 if (iNdEx + skippy) > l { 1262 return io.ErrUnexpectedEOF 1263 } 1264 iNdEx += skippy 1265 } 1266 } 1267 1268 if iNdEx > l { 1269 return io.ErrUnexpectedEOF 1270 } 1271 return nil 1272} 1273func (m *EndpointSlice) Unmarshal(dAtA []byte) error { 1274 l := len(dAtA) 1275 iNdEx := 0 1276 for iNdEx < l { 1277 preIndex := iNdEx 1278 var wire uint64 1279 for shift := uint(0); ; shift += 7 { 1280 if shift >= 64 { 1281 return ErrIntOverflowGenerated 1282 } 1283 if iNdEx >= l { 1284 return io.ErrUnexpectedEOF 1285 } 1286 b := dAtA[iNdEx] 1287 iNdEx++ 1288 wire |= uint64(b&0x7F) << shift 1289 if b < 0x80 { 1290 break 1291 } 1292 } 1293 fieldNum := int32(wire >> 3) 1294 wireType := int(wire & 0x7) 1295 if wireType == 4 { 1296 return fmt.Errorf("proto: EndpointSlice: wiretype end group for non-group") 1297 } 1298 if fieldNum <= 0 { 1299 return fmt.Errorf("proto: EndpointSlice: illegal tag %d (wire type %d)", fieldNum, wire) 1300 } 1301 switch fieldNum { 1302 case 1: 1303 if wireType != 2 { 1304 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 1305 } 1306 var msglen int 1307 for shift := uint(0); ; shift += 7 { 1308 if shift >= 64 { 1309 return ErrIntOverflowGenerated 1310 } 1311 if iNdEx >= l { 1312 return io.ErrUnexpectedEOF 1313 } 1314 b := dAtA[iNdEx] 1315 iNdEx++ 1316 msglen |= int(b&0x7F) << shift 1317 if b < 0x80 { 1318 break 1319 } 1320 } 1321 if msglen < 0 { 1322 return ErrInvalidLengthGenerated 1323 } 1324 postIndex := iNdEx + msglen 1325 if postIndex < 0 { 1326 return ErrInvalidLengthGenerated 1327 } 1328 if postIndex > l { 1329 return io.ErrUnexpectedEOF 1330 } 1331 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1332 return err 1333 } 1334 iNdEx = postIndex 1335 case 2: 1336 if wireType != 2 { 1337 return fmt.Errorf("proto: wrong wireType = %d for field Endpoints", wireType) 1338 } 1339 var msglen int 1340 for shift := uint(0); ; shift += 7 { 1341 if shift >= 64 { 1342 return ErrIntOverflowGenerated 1343 } 1344 if iNdEx >= l { 1345 return io.ErrUnexpectedEOF 1346 } 1347 b := dAtA[iNdEx] 1348 iNdEx++ 1349 msglen |= int(b&0x7F) << shift 1350 if b < 0x80 { 1351 break 1352 } 1353 } 1354 if msglen < 0 { 1355 return ErrInvalidLengthGenerated 1356 } 1357 postIndex := iNdEx + msglen 1358 if postIndex < 0 { 1359 return ErrInvalidLengthGenerated 1360 } 1361 if postIndex > l { 1362 return io.ErrUnexpectedEOF 1363 } 1364 m.Endpoints = append(m.Endpoints, Endpoint{}) 1365 if err := m.Endpoints[len(m.Endpoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1366 return err 1367 } 1368 iNdEx = postIndex 1369 case 3: 1370 if wireType != 2 { 1371 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType) 1372 } 1373 var msglen int 1374 for shift := uint(0); ; shift += 7 { 1375 if shift >= 64 { 1376 return ErrIntOverflowGenerated 1377 } 1378 if iNdEx >= l { 1379 return io.ErrUnexpectedEOF 1380 } 1381 b := dAtA[iNdEx] 1382 iNdEx++ 1383 msglen |= int(b&0x7F) << shift 1384 if b < 0x80 { 1385 break 1386 } 1387 } 1388 if msglen < 0 { 1389 return ErrInvalidLengthGenerated 1390 } 1391 postIndex := iNdEx + msglen 1392 if postIndex < 0 { 1393 return ErrInvalidLengthGenerated 1394 } 1395 if postIndex > l { 1396 return io.ErrUnexpectedEOF 1397 } 1398 m.Ports = append(m.Ports, EndpointPort{}) 1399 if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1400 return err 1401 } 1402 iNdEx = postIndex 1403 case 4: 1404 if wireType != 2 { 1405 return fmt.Errorf("proto: wrong wireType = %d for field AddressType", wireType) 1406 } 1407 var stringLen uint64 1408 for shift := uint(0); ; shift += 7 { 1409 if shift >= 64 { 1410 return ErrIntOverflowGenerated 1411 } 1412 if iNdEx >= l { 1413 return io.ErrUnexpectedEOF 1414 } 1415 b := dAtA[iNdEx] 1416 iNdEx++ 1417 stringLen |= uint64(b&0x7F) << shift 1418 if b < 0x80 { 1419 break 1420 } 1421 } 1422 intStringLen := int(stringLen) 1423 if intStringLen < 0 { 1424 return ErrInvalidLengthGenerated 1425 } 1426 postIndex := iNdEx + intStringLen 1427 if postIndex < 0 { 1428 return ErrInvalidLengthGenerated 1429 } 1430 if postIndex > l { 1431 return io.ErrUnexpectedEOF 1432 } 1433 s := AddressType(dAtA[iNdEx:postIndex]) 1434 m.AddressType = &s 1435 iNdEx = postIndex 1436 default: 1437 iNdEx = preIndex 1438 skippy, err := skipGenerated(dAtA[iNdEx:]) 1439 if err != nil { 1440 return err 1441 } 1442 if skippy < 0 { 1443 return ErrInvalidLengthGenerated 1444 } 1445 if (iNdEx + skippy) < 0 { 1446 return ErrInvalidLengthGenerated 1447 } 1448 if (iNdEx + skippy) > l { 1449 return io.ErrUnexpectedEOF 1450 } 1451 iNdEx += skippy 1452 } 1453 } 1454 1455 if iNdEx > l { 1456 return io.ErrUnexpectedEOF 1457 } 1458 return nil 1459} 1460func (m *EndpointSliceList) Unmarshal(dAtA []byte) error { 1461 l := len(dAtA) 1462 iNdEx := 0 1463 for iNdEx < l { 1464 preIndex := iNdEx 1465 var wire uint64 1466 for shift := uint(0); ; shift += 7 { 1467 if shift >= 64 { 1468 return ErrIntOverflowGenerated 1469 } 1470 if iNdEx >= l { 1471 return io.ErrUnexpectedEOF 1472 } 1473 b := dAtA[iNdEx] 1474 iNdEx++ 1475 wire |= uint64(b&0x7F) << shift 1476 if b < 0x80 { 1477 break 1478 } 1479 } 1480 fieldNum := int32(wire >> 3) 1481 wireType := int(wire & 0x7) 1482 if wireType == 4 { 1483 return fmt.Errorf("proto: EndpointSliceList: wiretype end group for non-group") 1484 } 1485 if fieldNum <= 0 { 1486 return fmt.Errorf("proto: EndpointSliceList: illegal tag %d (wire type %d)", fieldNum, wire) 1487 } 1488 switch fieldNum { 1489 case 1: 1490 if wireType != 2 { 1491 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 1492 } 1493 var msglen int 1494 for shift := uint(0); ; shift += 7 { 1495 if shift >= 64 { 1496 return ErrIntOverflowGenerated 1497 } 1498 if iNdEx >= l { 1499 return io.ErrUnexpectedEOF 1500 } 1501 b := dAtA[iNdEx] 1502 iNdEx++ 1503 msglen |= int(b&0x7F) << shift 1504 if b < 0x80 { 1505 break 1506 } 1507 } 1508 if msglen < 0 { 1509 return ErrInvalidLengthGenerated 1510 } 1511 postIndex := iNdEx + msglen 1512 if postIndex < 0 { 1513 return ErrInvalidLengthGenerated 1514 } 1515 if postIndex > l { 1516 return io.ErrUnexpectedEOF 1517 } 1518 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1519 return err 1520 } 1521 iNdEx = postIndex 1522 case 2: 1523 if wireType != 2 { 1524 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 1525 } 1526 var msglen int 1527 for shift := uint(0); ; shift += 7 { 1528 if shift >= 64 { 1529 return ErrIntOverflowGenerated 1530 } 1531 if iNdEx >= l { 1532 return io.ErrUnexpectedEOF 1533 } 1534 b := dAtA[iNdEx] 1535 iNdEx++ 1536 msglen |= int(b&0x7F) << shift 1537 if b < 0x80 { 1538 break 1539 } 1540 } 1541 if msglen < 0 { 1542 return ErrInvalidLengthGenerated 1543 } 1544 postIndex := iNdEx + msglen 1545 if postIndex < 0 { 1546 return ErrInvalidLengthGenerated 1547 } 1548 if postIndex > l { 1549 return io.ErrUnexpectedEOF 1550 } 1551 m.Items = append(m.Items, EndpointSlice{}) 1552 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1553 return err 1554 } 1555 iNdEx = postIndex 1556 default: 1557 iNdEx = preIndex 1558 skippy, err := skipGenerated(dAtA[iNdEx:]) 1559 if err != nil { 1560 return err 1561 } 1562 if skippy < 0 { 1563 return ErrInvalidLengthGenerated 1564 } 1565 if (iNdEx + skippy) < 0 { 1566 return ErrInvalidLengthGenerated 1567 } 1568 if (iNdEx + skippy) > l { 1569 return io.ErrUnexpectedEOF 1570 } 1571 iNdEx += skippy 1572 } 1573 } 1574 1575 if iNdEx > l { 1576 return io.ErrUnexpectedEOF 1577 } 1578 return nil 1579} 1580func skipGenerated(dAtA []byte) (n int, err error) { 1581 l := len(dAtA) 1582 iNdEx := 0 1583 for iNdEx < l { 1584 var wire uint64 1585 for shift := uint(0); ; shift += 7 { 1586 if shift >= 64 { 1587 return 0, ErrIntOverflowGenerated 1588 } 1589 if iNdEx >= l { 1590 return 0, io.ErrUnexpectedEOF 1591 } 1592 b := dAtA[iNdEx] 1593 iNdEx++ 1594 wire |= (uint64(b) & 0x7F) << shift 1595 if b < 0x80 { 1596 break 1597 } 1598 } 1599 wireType := int(wire & 0x7) 1600 switch wireType { 1601 case 0: 1602 for shift := uint(0); ; shift += 7 { 1603 if shift >= 64 { 1604 return 0, ErrIntOverflowGenerated 1605 } 1606 if iNdEx >= l { 1607 return 0, io.ErrUnexpectedEOF 1608 } 1609 iNdEx++ 1610 if dAtA[iNdEx-1] < 0x80 { 1611 break 1612 } 1613 } 1614 return iNdEx, nil 1615 case 1: 1616 iNdEx += 8 1617 return iNdEx, nil 1618 case 2: 1619 var length int 1620 for shift := uint(0); ; shift += 7 { 1621 if shift >= 64 { 1622 return 0, ErrIntOverflowGenerated 1623 } 1624 if iNdEx >= l { 1625 return 0, io.ErrUnexpectedEOF 1626 } 1627 b := dAtA[iNdEx] 1628 iNdEx++ 1629 length |= (int(b) & 0x7F) << shift 1630 if b < 0x80 { 1631 break 1632 } 1633 } 1634 if length < 0 { 1635 return 0, ErrInvalidLengthGenerated 1636 } 1637 iNdEx += length 1638 if iNdEx < 0 { 1639 return 0, ErrInvalidLengthGenerated 1640 } 1641 return iNdEx, nil 1642 case 3: 1643 for { 1644 var innerWire uint64 1645 var start int = iNdEx 1646 for shift := uint(0); ; shift += 7 { 1647 if shift >= 64 { 1648 return 0, ErrIntOverflowGenerated 1649 } 1650 if iNdEx >= l { 1651 return 0, io.ErrUnexpectedEOF 1652 } 1653 b := dAtA[iNdEx] 1654 iNdEx++ 1655 innerWire |= (uint64(b) & 0x7F) << shift 1656 if b < 0x80 { 1657 break 1658 } 1659 } 1660 innerWireType := int(innerWire & 0x7) 1661 if innerWireType == 4 { 1662 break 1663 } 1664 next, err := skipGenerated(dAtA[start:]) 1665 if err != nil { 1666 return 0, err 1667 } 1668 iNdEx = start + next 1669 if iNdEx < 0 { 1670 return 0, ErrInvalidLengthGenerated 1671 } 1672 } 1673 return iNdEx, nil 1674 case 4: 1675 return iNdEx, nil 1676 case 5: 1677 iNdEx += 4 1678 return iNdEx, nil 1679 default: 1680 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1681 } 1682 } 1683 panic("unreachable") 1684} 1685 1686var ( 1687 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") 1688 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") 1689) 1690