1
16
17
18
19
20 package v1alpha1
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
29
30 math "math"
31 math_bits "math/bits"
32 reflect "reflect"
33 strings "strings"
34 )
35
36
37 var _ = proto.Marshal
38 var _ = fmt.Errorf
39 var _ = math.Inf
40
41
42
43
44
45 const _ = proto.GoGoProtoPackageIsVersion3
46
47 func (m *IPAddress) Reset() { *m = IPAddress{} }
48 func (*IPAddress) ProtoMessage() {}
49 func (*IPAddress) Descriptor() ([]byte, []int) {
50 return fileDescriptor_c1cb39e7b48ce50d, []int{0}
51 }
52 func (m *IPAddress) XXX_Unmarshal(b []byte) error {
53 return m.Unmarshal(b)
54 }
55 func (m *IPAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
56 b = b[:cap(b)]
57 n, err := m.MarshalToSizedBuffer(b)
58 if err != nil {
59 return nil, err
60 }
61 return b[:n], nil
62 }
63 func (m *IPAddress) XXX_Merge(src proto.Message) {
64 xxx_messageInfo_IPAddress.Merge(m, src)
65 }
66 func (m *IPAddress) XXX_Size() int {
67 return m.Size()
68 }
69 func (m *IPAddress) XXX_DiscardUnknown() {
70 xxx_messageInfo_IPAddress.DiscardUnknown(m)
71 }
72
73 var xxx_messageInfo_IPAddress proto.InternalMessageInfo
74
75 func (m *IPAddressList) Reset() { *m = IPAddressList{} }
76 func (*IPAddressList) ProtoMessage() {}
77 func (*IPAddressList) Descriptor() ([]byte, []int) {
78 return fileDescriptor_c1cb39e7b48ce50d, []int{1}
79 }
80 func (m *IPAddressList) XXX_Unmarshal(b []byte) error {
81 return m.Unmarshal(b)
82 }
83 func (m *IPAddressList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
84 b = b[:cap(b)]
85 n, err := m.MarshalToSizedBuffer(b)
86 if err != nil {
87 return nil, err
88 }
89 return b[:n], nil
90 }
91 func (m *IPAddressList) XXX_Merge(src proto.Message) {
92 xxx_messageInfo_IPAddressList.Merge(m, src)
93 }
94 func (m *IPAddressList) XXX_Size() int {
95 return m.Size()
96 }
97 func (m *IPAddressList) XXX_DiscardUnknown() {
98 xxx_messageInfo_IPAddressList.DiscardUnknown(m)
99 }
100
101 var xxx_messageInfo_IPAddressList proto.InternalMessageInfo
102
103 func (m *IPAddressSpec) Reset() { *m = IPAddressSpec{} }
104 func (*IPAddressSpec) ProtoMessage() {}
105 func (*IPAddressSpec) Descriptor() ([]byte, []int) {
106 return fileDescriptor_c1cb39e7b48ce50d, []int{2}
107 }
108 func (m *IPAddressSpec) XXX_Unmarshal(b []byte) error {
109 return m.Unmarshal(b)
110 }
111 func (m *IPAddressSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
112 b = b[:cap(b)]
113 n, err := m.MarshalToSizedBuffer(b)
114 if err != nil {
115 return nil, err
116 }
117 return b[:n], nil
118 }
119 func (m *IPAddressSpec) XXX_Merge(src proto.Message) {
120 xxx_messageInfo_IPAddressSpec.Merge(m, src)
121 }
122 func (m *IPAddressSpec) XXX_Size() int {
123 return m.Size()
124 }
125 func (m *IPAddressSpec) XXX_DiscardUnknown() {
126 xxx_messageInfo_IPAddressSpec.DiscardUnknown(m)
127 }
128
129 var xxx_messageInfo_IPAddressSpec proto.InternalMessageInfo
130
131 func (m *ParentReference) Reset() { *m = ParentReference{} }
132 func (*ParentReference) ProtoMessage() {}
133 func (*ParentReference) Descriptor() ([]byte, []int) {
134 return fileDescriptor_c1cb39e7b48ce50d, []int{3}
135 }
136 func (m *ParentReference) XXX_Unmarshal(b []byte) error {
137 return m.Unmarshal(b)
138 }
139 func (m *ParentReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
140 b = b[:cap(b)]
141 n, err := m.MarshalToSizedBuffer(b)
142 if err != nil {
143 return nil, err
144 }
145 return b[:n], nil
146 }
147 func (m *ParentReference) XXX_Merge(src proto.Message) {
148 xxx_messageInfo_ParentReference.Merge(m, src)
149 }
150 func (m *ParentReference) XXX_Size() int {
151 return m.Size()
152 }
153 func (m *ParentReference) XXX_DiscardUnknown() {
154 xxx_messageInfo_ParentReference.DiscardUnknown(m)
155 }
156
157 var xxx_messageInfo_ParentReference proto.InternalMessageInfo
158
159 func (m *ServiceCIDR) Reset() { *m = ServiceCIDR{} }
160 func (*ServiceCIDR) ProtoMessage() {}
161 func (*ServiceCIDR) Descriptor() ([]byte, []int) {
162 return fileDescriptor_c1cb39e7b48ce50d, []int{4}
163 }
164 func (m *ServiceCIDR) XXX_Unmarshal(b []byte) error {
165 return m.Unmarshal(b)
166 }
167 func (m *ServiceCIDR) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
168 b = b[:cap(b)]
169 n, err := m.MarshalToSizedBuffer(b)
170 if err != nil {
171 return nil, err
172 }
173 return b[:n], nil
174 }
175 func (m *ServiceCIDR) XXX_Merge(src proto.Message) {
176 xxx_messageInfo_ServiceCIDR.Merge(m, src)
177 }
178 func (m *ServiceCIDR) XXX_Size() int {
179 return m.Size()
180 }
181 func (m *ServiceCIDR) XXX_DiscardUnknown() {
182 xxx_messageInfo_ServiceCIDR.DiscardUnknown(m)
183 }
184
185 var xxx_messageInfo_ServiceCIDR proto.InternalMessageInfo
186
187 func (m *ServiceCIDRList) Reset() { *m = ServiceCIDRList{} }
188 func (*ServiceCIDRList) ProtoMessage() {}
189 func (*ServiceCIDRList) Descriptor() ([]byte, []int) {
190 return fileDescriptor_c1cb39e7b48ce50d, []int{5}
191 }
192 func (m *ServiceCIDRList) XXX_Unmarshal(b []byte) error {
193 return m.Unmarshal(b)
194 }
195 func (m *ServiceCIDRList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
196 b = b[:cap(b)]
197 n, err := m.MarshalToSizedBuffer(b)
198 if err != nil {
199 return nil, err
200 }
201 return b[:n], nil
202 }
203 func (m *ServiceCIDRList) XXX_Merge(src proto.Message) {
204 xxx_messageInfo_ServiceCIDRList.Merge(m, src)
205 }
206 func (m *ServiceCIDRList) XXX_Size() int {
207 return m.Size()
208 }
209 func (m *ServiceCIDRList) XXX_DiscardUnknown() {
210 xxx_messageInfo_ServiceCIDRList.DiscardUnknown(m)
211 }
212
213 var xxx_messageInfo_ServiceCIDRList proto.InternalMessageInfo
214
215 func (m *ServiceCIDRSpec) Reset() { *m = ServiceCIDRSpec{} }
216 func (*ServiceCIDRSpec) ProtoMessage() {}
217 func (*ServiceCIDRSpec) Descriptor() ([]byte, []int) {
218 return fileDescriptor_c1cb39e7b48ce50d, []int{6}
219 }
220 func (m *ServiceCIDRSpec) XXX_Unmarshal(b []byte) error {
221 return m.Unmarshal(b)
222 }
223 func (m *ServiceCIDRSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
224 b = b[:cap(b)]
225 n, err := m.MarshalToSizedBuffer(b)
226 if err != nil {
227 return nil, err
228 }
229 return b[:n], nil
230 }
231 func (m *ServiceCIDRSpec) XXX_Merge(src proto.Message) {
232 xxx_messageInfo_ServiceCIDRSpec.Merge(m, src)
233 }
234 func (m *ServiceCIDRSpec) XXX_Size() int {
235 return m.Size()
236 }
237 func (m *ServiceCIDRSpec) XXX_DiscardUnknown() {
238 xxx_messageInfo_ServiceCIDRSpec.DiscardUnknown(m)
239 }
240
241 var xxx_messageInfo_ServiceCIDRSpec proto.InternalMessageInfo
242
243 func (m *ServiceCIDRStatus) Reset() { *m = ServiceCIDRStatus{} }
244 func (*ServiceCIDRStatus) ProtoMessage() {}
245 func (*ServiceCIDRStatus) Descriptor() ([]byte, []int) {
246 return fileDescriptor_c1cb39e7b48ce50d, []int{7}
247 }
248 func (m *ServiceCIDRStatus) XXX_Unmarshal(b []byte) error {
249 return m.Unmarshal(b)
250 }
251 func (m *ServiceCIDRStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
252 b = b[:cap(b)]
253 n, err := m.MarshalToSizedBuffer(b)
254 if err != nil {
255 return nil, err
256 }
257 return b[:n], nil
258 }
259 func (m *ServiceCIDRStatus) XXX_Merge(src proto.Message) {
260 xxx_messageInfo_ServiceCIDRStatus.Merge(m, src)
261 }
262 func (m *ServiceCIDRStatus) XXX_Size() int {
263 return m.Size()
264 }
265 func (m *ServiceCIDRStatus) XXX_DiscardUnknown() {
266 xxx_messageInfo_ServiceCIDRStatus.DiscardUnknown(m)
267 }
268
269 var xxx_messageInfo_ServiceCIDRStatus proto.InternalMessageInfo
270
271 func init() {
272 proto.RegisterType((*IPAddress)(nil), "k8s.io.api.networking.v1alpha1.IPAddress")
273 proto.RegisterType((*IPAddressList)(nil), "k8s.io.api.networking.v1alpha1.IPAddressList")
274 proto.RegisterType((*IPAddressSpec)(nil), "k8s.io.api.networking.v1alpha1.IPAddressSpec")
275 proto.RegisterType((*ParentReference)(nil), "k8s.io.api.networking.v1alpha1.ParentReference")
276 proto.RegisterType((*ServiceCIDR)(nil), "k8s.io.api.networking.v1alpha1.ServiceCIDR")
277 proto.RegisterType((*ServiceCIDRList)(nil), "k8s.io.api.networking.v1alpha1.ServiceCIDRList")
278 proto.RegisterType((*ServiceCIDRSpec)(nil), "k8s.io.api.networking.v1alpha1.ServiceCIDRSpec")
279 proto.RegisterType((*ServiceCIDRStatus)(nil), "k8s.io.api.networking.v1alpha1.ServiceCIDRStatus")
280 }
281
282 func init() {
283 proto.RegisterFile("k8s.io/api/networking/v1alpha1/generated.proto", fileDescriptor_c1cb39e7b48ce50d)
284 }
285
286 var fileDescriptor_c1cb39e7b48ce50d = []byte{
287
288 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcd, 0x6e, 0xd3, 0x4a,
289 0x18, 0x8d, 0xdb, 0xa4, 0xaa, 0x27, 0xb7, 0xb7, 0xb7, 0x5e, 0x45, 0x5d, 0x38, 0x91, 0xef, 0xa6,
290 0x08, 0x3a, 0x26, 0x11, 0x42, 0x6c, 0x71, 0x2b, 0xa1, 0x4a, 0xd0, 0x96, 0xe9, 0x0a, 0xd4, 0x05,
291 0xd3, 0xc9, 0x57, 0x67, 0x08, 0xfe, 0xd1, 0xcc, 0x24, 0xc0, 0x8e, 0x47, 0xe0, 0x05, 0x78, 0x0e,
292 0x56, 0x20, 0xb1, 0xeb, 0xb2, 0xcb, 0xae, 0x2a, 0x6a, 0x5e, 0x04, 0xcd, 0xd8, 0xb1, 0x93, 0x46,
293 0xfd, 0xdb, 0x74, 0xe7, 0xef, 0xcc, 0x39, 0x67, 0xbe, 0xf3, 0xcd, 0x8c, 0x8c, 0xf0, 0xf0, 0x99,
294 0xc4, 0x3c, 0xf1, 0x69, 0xca, 0xfd, 0x18, 0xd4, 0xc7, 0x44, 0x0c, 0x79, 0x1c, 0xfa, 0xe3, 0x2e,
295 0xfd, 0x90, 0x0e, 0x68, 0xd7, 0x0f, 0x21, 0x06, 0x41, 0x15, 0xf4, 0x71, 0x2a, 0x12, 0x95, 0x38,
296 0x6e, 0xce, 0xc7, 0x34, 0xe5, 0xb8, 0xe2, 0xe3, 0x09, 0x7f, 0x7d, 0x33, 0xe4, 0x6a, 0x30, 0x3a,
297 0xc2, 0x2c, 0x89, 0xfc, 0x30, 0x09, 0x13, 0xdf, 0xc8, 0x8e, 0x46, 0xc7, 0xa6, 0x32, 0x85, 0xf9,
298 0xca, 0xed, 0xd6, 0x9f, 0x54, 0xdb, 0x47, 0x94, 0x0d, 0x78, 0x0c, 0xe2, 0xb3, 0x9f, 0x0e, 0x43,
299 0x0d, 0x48, 0x3f, 0x02, 0x45, 0xfd, 0xf1, 0x5c, 0x13, 0xeb, 0xfe, 0x55, 0x2a, 0x31, 0x8a, 0x15,
300 0x8f, 0x60, 0x4e, 0xf0, 0xf4, 0x26, 0x81, 0x64, 0x03, 0x88, 0xe8, 0x65, 0x9d, 0xf7, 0xd3, 0x42,
301 0xf6, 0xce, 0xfe, 0xf3, 0x7e, 0x5f, 0x80, 0x94, 0xce, 0x3b, 0xb4, 0xac, 0x3b, 0xea, 0x53, 0x45,
302 0x5b, 0x56, 0xc7, 0xda, 0x68, 0xf6, 0x1e, 0xe3, 0x6a, 0x1c, 0xa5, 0x31, 0x4e, 0x87, 0xa1, 0x06,
303 0x24, 0xd6, 0x6c, 0x3c, 0xee, 0xe2, 0xbd, 0xa3, 0xf7, 0xc0, 0xd4, 0x2b, 0x50, 0x34, 0x70, 0x4e,
304 0xce, 0xdb, 0xb5, 0xec, 0xbc, 0x8d, 0x2a, 0x8c, 0x94, 0xae, 0xce, 0x1e, 0xaa, 0xcb, 0x14, 0x58,
305 0x6b, 0xc1, 0xb8, 0x6f, 0xe2, 0xeb, 0x87, 0x8d, 0xcb, 0xd6, 0x0e, 0x52, 0x60, 0xc1, 0x3f, 0x85,
306 0x75, 0x5d, 0x57, 0xc4, 0x18, 0x79, 0x3f, 0x2c, 0xb4, 0x52, 0xb2, 0x5e, 0x72, 0xa9, 0x9c, 0xc3,
307 0xb9, 0x10, 0xf8, 0x76, 0x21, 0xb4, 0xda, 0x44, 0xf8, 0xaf, 0xd8, 0x67, 0x79, 0x82, 0x4c, 0x05,
308 0xd8, 0x45, 0x0d, 0xae, 0x20, 0x92, 0xad, 0x85, 0xce, 0xe2, 0x46, 0xb3, 0xf7, 0xe0, 0xd6, 0x09,
309 0x82, 0x95, 0xc2, 0xb5, 0xb1, 0xa3, 0xf5, 0x24, 0xb7, 0xf1, 0xa2, 0xa9, 0xf6, 0x75, 0x2c, 0xe7,
310 0x10, 0xd9, 0x29, 0x15, 0x10, 0x2b, 0x02, 0xc7, 0x45, 0xff, 0xfe, 0x4d, 0x9b, 0xec, 0x4f, 0x04,
311 0x20, 0x20, 0x66, 0x10, 0xac, 0x64, 0xe7, 0x6d, 0xbb, 0x04, 0x49, 0x65, 0xe8, 0x7d, 0xb7, 0xd0,
312 0xea, 0x25, 0xb6, 0xf3, 0x3f, 0x6a, 0x84, 0x22, 0x19, 0xa5, 0x66, 0x37, 0xbb, 0xea, 0xf3, 0x85,
313 0x06, 0x49, 0xbe, 0xe6, 0x3c, 0x42, 0xcb, 0x02, 0x64, 0x32, 0x12, 0x0c, 0xcc, 0xe1, 0xd9, 0xd5,
314 0x94, 0x48, 0x81, 0x93, 0x92, 0xe1, 0xf8, 0xc8, 0x8e, 0x69, 0x04, 0x32, 0xa5, 0x0c, 0x5a, 0x8b,
315 0x86, 0xbe, 0x56, 0xd0, 0xed, 0xdd, 0xc9, 0x02, 0xa9, 0x38, 0x4e, 0x07, 0xd5, 0x75, 0xd1, 0xaa,
316 0x1b, 0x6e, 0x79, 0xd0, 0x9a, 0x4b, 0xcc, 0x8a, 0xf7, 0x6d, 0x01, 0x35, 0x0f, 0x40, 0x8c, 0x39,
317 0x83, 0xad, 0x9d, 0x6d, 0x72, 0x0f, 0x77, 0xf5, 0xf5, 0xcc, 0x5d, 0xbd, 0xf1, 0x10, 0xa6, 0x9a,
318 0xbb, 0xea, 0xb6, 0x3a, 0x6f, 0xd0, 0x92, 0x54, 0x54, 0x8d, 0xa4, 0x19, 0x4a, 0xb3, 0xd7, 0xbd,
319 0x8b, 0xa9, 0x11, 0x06, 0xff, 0x16, 0xb6, 0x4b, 0x79, 0x4d, 0x0a, 0x43, 0xef, 0x97, 0x85, 0x56,
320 0xa7, 0xd8, 0xf7, 0xf0, 0x14, 0xf6, 0x67, 0x9f, 0xc2, 0xc3, 0x3b, 0x64, 0xb9, 0xe2, 0x31, 0xf4,
321 0x66, 0x22, 0x98, 0xe7, 0xd0, 0x46, 0x0d, 0xc6, 0xfb, 0x42, 0xb6, 0xac, 0xce, 0xe2, 0x86, 0x1d,
322 0xd8, 0x5a, 0xa3, 0x17, 0x25, 0xc9, 0x71, 0xef, 0x13, 0x5a, 0x9b, 0x1b, 0x92, 0xc3, 0x10, 0x62,
323 0x49, 0xdc, 0xe7, 0x8a, 0x27, 0x71, 0x2e, 0x9d, 0x3d, 0xc0, 0x6b, 0xa2, 0x6f, 0x4d, 0x74, 0xd5,
324 0xed, 0x28, 0x21, 0x49, 0xa6, 0x6c, 0x83, 0xed, 0x93, 0x0b, 0xb7, 0x76, 0x7a, 0xe1, 0xd6, 0xce,
325 0x2e, 0xdc, 0xda, 0x97, 0xcc, 0xb5, 0x4e, 0x32, 0xd7, 0x3a, 0xcd, 0x5c, 0xeb, 0x2c, 0x73, 0xad,
326 0xdf, 0x99, 0x6b, 0x7d, 0xfd, 0xe3, 0xd6, 0xde, 0xba, 0xd7, 0xff, 0x7f, 0xfe, 0x06, 0x00, 0x00,
327 0xff, 0xff, 0xb1, 0xd0, 0x33, 0x02, 0xa0, 0x06, 0x00, 0x00,
328 }
329
330 func (m *IPAddress) Marshal() (dAtA []byte, err error) {
331 size := m.Size()
332 dAtA = make([]byte, size)
333 n, err := m.MarshalToSizedBuffer(dAtA[:size])
334 if err != nil {
335 return nil, err
336 }
337 return dAtA[:n], nil
338 }
339
340 func (m *IPAddress) MarshalTo(dAtA []byte) (int, error) {
341 size := m.Size()
342 return m.MarshalToSizedBuffer(dAtA[:size])
343 }
344
345 func (m *IPAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
346 i := len(dAtA)
347 _ = i
348 var l int
349 _ = l
350 {
351 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
352 if err != nil {
353 return 0, err
354 }
355 i -= size
356 i = encodeVarintGenerated(dAtA, i, uint64(size))
357 }
358 i--
359 dAtA[i] = 0x12
360 {
361 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
362 if err != nil {
363 return 0, err
364 }
365 i -= size
366 i = encodeVarintGenerated(dAtA, i, uint64(size))
367 }
368 i--
369 dAtA[i] = 0xa
370 return len(dAtA) - i, nil
371 }
372
373 func (m *IPAddressList) Marshal() (dAtA []byte, err error) {
374 size := m.Size()
375 dAtA = make([]byte, size)
376 n, err := m.MarshalToSizedBuffer(dAtA[:size])
377 if err != nil {
378 return nil, err
379 }
380 return dAtA[:n], nil
381 }
382
383 func (m *IPAddressList) MarshalTo(dAtA []byte) (int, error) {
384 size := m.Size()
385 return m.MarshalToSizedBuffer(dAtA[:size])
386 }
387
388 func (m *IPAddressList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
389 i := len(dAtA)
390 _ = i
391 var l int
392 _ = l
393 if len(m.Items) > 0 {
394 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
395 {
396 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
397 if err != nil {
398 return 0, err
399 }
400 i -= size
401 i = encodeVarintGenerated(dAtA, i, uint64(size))
402 }
403 i--
404 dAtA[i] = 0x12
405 }
406 }
407 {
408 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
409 if err != nil {
410 return 0, err
411 }
412 i -= size
413 i = encodeVarintGenerated(dAtA, i, uint64(size))
414 }
415 i--
416 dAtA[i] = 0xa
417 return len(dAtA) - i, nil
418 }
419
420 func (m *IPAddressSpec) Marshal() (dAtA []byte, err error) {
421 size := m.Size()
422 dAtA = make([]byte, size)
423 n, err := m.MarshalToSizedBuffer(dAtA[:size])
424 if err != nil {
425 return nil, err
426 }
427 return dAtA[:n], nil
428 }
429
430 func (m *IPAddressSpec) MarshalTo(dAtA []byte) (int, error) {
431 size := m.Size()
432 return m.MarshalToSizedBuffer(dAtA[:size])
433 }
434
435 func (m *IPAddressSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
436 i := len(dAtA)
437 _ = i
438 var l int
439 _ = l
440 if m.ParentRef != nil {
441 {
442 size, err := m.ParentRef.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] = 0xa
451 }
452 return len(dAtA) - i, nil
453 }
454
455 func (m *ParentReference) Marshal() (dAtA []byte, err error) {
456 size := m.Size()
457 dAtA = make([]byte, size)
458 n, err := m.MarshalToSizedBuffer(dAtA[:size])
459 if err != nil {
460 return nil, err
461 }
462 return dAtA[:n], nil
463 }
464
465 func (m *ParentReference) MarshalTo(dAtA []byte) (int, error) {
466 size := m.Size()
467 return m.MarshalToSizedBuffer(dAtA[:size])
468 }
469
470 func (m *ParentReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
471 i := len(dAtA)
472 _ = i
473 var l int
474 _ = l
475 i -= len(m.Name)
476 copy(dAtA[i:], m.Name)
477 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
478 i--
479 dAtA[i] = 0x22
480 i -= len(m.Namespace)
481 copy(dAtA[i:], m.Namespace)
482 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
483 i--
484 dAtA[i] = 0x1a
485 i -= len(m.Resource)
486 copy(dAtA[i:], m.Resource)
487 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
488 i--
489 dAtA[i] = 0x12
490 i -= len(m.Group)
491 copy(dAtA[i:], m.Group)
492 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
493 i--
494 dAtA[i] = 0xa
495 return len(dAtA) - i, nil
496 }
497
498 func (m *ServiceCIDR) Marshal() (dAtA []byte, err error) {
499 size := m.Size()
500 dAtA = make([]byte, size)
501 n, err := m.MarshalToSizedBuffer(dAtA[:size])
502 if err != nil {
503 return nil, err
504 }
505 return dAtA[:n], nil
506 }
507
508 func (m *ServiceCIDR) MarshalTo(dAtA []byte) (int, error) {
509 size := m.Size()
510 return m.MarshalToSizedBuffer(dAtA[:size])
511 }
512
513 func (m *ServiceCIDR) MarshalToSizedBuffer(dAtA []byte) (int, error) {
514 i := len(dAtA)
515 _ = i
516 var l int
517 _ = l
518 {
519 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
520 if err != nil {
521 return 0, err
522 }
523 i -= size
524 i = encodeVarintGenerated(dAtA, i, uint64(size))
525 }
526 i--
527 dAtA[i] = 0x1a
528 {
529 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
530 if err != nil {
531 return 0, err
532 }
533 i -= size
534 i = encodeVarintGenerated(dAtA, i, uint64(size))
535 }
536 i--
537 dAtA[i] = 0x12
538 {
539 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
540 if err != nil {
541 return 0, err
542 }
543 i -= size
544 i = encodeVarintGenerated(dAtA, i, uint64(size))
545 }
546 i--
547 dAtA[i] = 0xa
548 return len(dAtA) - i, nil
549 }
550
551 func (m *ServiceCIDRList) Marshal() (dAtA []byte, err error) {
552 size := m.Size()
553 dAtA = make([]byte, size)
554 n, err := m.MarshalToSizedBuffer(dAtA[:size])
555 if err != nil {
556 return nil, err
557 }
558 return dAtA[:n], nil
559 }
560
561 func (m *ServiceCIDRList) MarshalTo(dAtA []byte) (int, error) {
562 size := m.Size()
563 return m.MarshalToSizedBuffer(dAtA[:size])
564 }
565
566 func (m *ServiceCIDRList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
567 i := len(dAtA)
568 _ = i
569 var l int
570 _ = l
571 if len(m.Items) > 0 {
572 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
573 {
574 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
575 if err != nil {
576 return 0, err
577 }
578 i -= size
579 i = encodeVarintGenerated(dAtA, i, uint64(size))
580 }
581 i--
582 dAtA[i] = 0x12
583 }
584 }
585 {
586 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
587 if err != nil {
588 return 0, err
589 }
590 i -= size
591 i = encodeVarintGenerated(dAtA, i, uint64(size))
592 }
593 i--
594 dAtA[i] = 0xa
595 return len(dAtA) - i, nil
596 }
597
598 func (m *ServiceCIDRSpec) Marshal() (dAtA []byte, err error) {
599 size := m.Size()
600 dAtA = make([]byte, size)
601 n, err := m.MarshalToSizedBuffer(dAtA[:size])
602 if err != nil {
603 return nil, err
604 }
605 return dAtA[:n], nil
606 }
607
608 func (m *ServiceCIDRSpec) MarshalTo(dAtA []byte) (int, error) {
609 size := m.Size()
610 return m.MarshalToSizedBuffer(dAtA[:size])
611 }
612
613 func (m *ServiceCIDRSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
614 i := len(dAtA)
615 _ = i
616 var l int
617 _ = l
618 if len(m.CIDRs) > 0 {
619 for iNdEx := len(m.CIDRs) - 1; iNdEx >= 0; iNdEx-- {
620 i -= len(m.CIDRs[iNdEx])
621 copy(dAtA[i:], m.CIDRs[iNdEx])
622 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDRs[iNdEx])))
623 i--
624 dAtA[i] = 0xa
625 }
626 }
627 return len(dAtA) - i, nil
628 }
629
630 func (m *ServiceCIDRStatus) Marshal() (dAtA []byte, err error) {
631 size := m.Size()
632 dAtA = make([]byte, size)
633 n, err := m.MarshalToSizedBuffer(dAtA[:size])
634 if err != nil {
635 return nil, err
636 }
637 return dAtA[:n], nil
638 }
639
640 func (m *ServiceCIDRStatus) MarshalTo(dAtA []byte) (int, error) {
641 size := m.Size()
642 return m.MarshalToSizedBuffer(dAtA[:size])
643 }
644
645 func (m *ServiceCIDRStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
646 i := len(dAtA)
647 _ = i
648 var l int
649 _ = l
650 if len(m.Conditions) > 0 {
651 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
652 {
653 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
654 if err != nil {
655 return 0, err
656 }
657 i -= size
658 i = encodeVarintGenerated(dAtA, i, uint64(size))
659 }
660 i--
661 dAtA[i] = 0xa
662 }
663 }
664 return len(dAtA) - i, nil
665 }
666
667 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
668 offset -= sovGenerated(v)
669 base := offset
670 for v >= 1<<7 {
671 dAtA[offset] = uint8(v&0x7f | 0x80)
672 v >>= 7
673 offset++
674 }
675 dAtA[offset] = uint8(v)
676 return base
677 }
678 func (m *IPAddress) Size() (n int) {
679 if m == nil {
680 return 0
681 }
682 var l int
683 _ = l
684 l = m.ObjectMeta.Size()
685 n += 1 + l + sovGenerated(uint64(l))
686 l = m.Spec.Size()
687 n += 1 + l + sovGenerated(uint64(l))
688 return n
689 }
690
691 func (m *IPAddressList) Size() (n int) {
692 if m == nil {
693 return 0
694 }
695 var l int
696 _ = l
697 l = m.ListMeta.Size()
698 n += 1 + l + sovGenerated(uint64(l))
699 if len(m.Items) > 0 {
700 for _, e := range m.Items {
701 l = e.Size()
702 n += 1 + l + sovGenerated(uint64(l))
703 }
704 }
705 return n
706 }
707
708 func (m *IPAddressSpec) Size() (n int) {
709 if m == nil {
710 return 0
711 }
712 var l int
713 _ = l
714 if m.ParentRef != nil {
715 l = m.ParentRef.Size()
716 n += 1 + l + sovGenerated(uint64(l))
717 }
718 return n
719 }
720
721 func (m *ParentReference) Size() (n int) {
722 if m == nil {
723 return 0
724 }
725 var l int
726 _ = l
727 l = len(m.Group)
728 n += 1 + l + sovGenerated(uint64(l))
729 l = len(m.Resource)
730 n += 1 + l + sovGenerated(uint64(l))
731 l = len(m.Namespace)
732 n += 1 + l + sovGenerated(uint64(l))
733 l = len(m.Name)
734 n += 1 + l + sovGenerated(uint64(l))
735 return n
736 }
737
738 func (m *ServiceCIDR) Size() (n int) {
739 if m == nil {
740 return 0
741 }
742 var l int
743 _ = l
744 l = m.ObjectMeta.Size()
745 n += 1 + l + sovGenerated(uint64(l))
746 l = m.Spec.Size()
747 n += 1 + l + sovGenerated(uint64(l))
748 l = m.Status.Size()
749 n += 1 + l + sovGenerated(uint64(l))
750 return n
751 }
752
753 func (m *ServiceCIDRList) Size() (n int) {
754 if m == nil {
755 return 0
756 }
757 var l int
758 _ = l
759 l = m.ListMeta.Size()
760 n += 1 + l + sovGenerated(uint64(l))
761 if len(m.Items) > 0 {
762 for _, e := range m.Items {
763 l = e.Size()
764 n += 1 + l + sovGenerated(uint64(l))
765 }
766 }
767 return n
768 }
769
770 func (m *ServiceCIDRSpec) Size() (n int) {
771 if m == nil {
772 return 0
773 }
774 var l int
775 _ = l
776 if len(m.CIDRs) > 0 {
777 for _, s := range m.CIDRs {
778 l = len(s)
779 n += 1 + l + sovGenerated(uint64(l))
780 }
781 }
782 return n
783 }
784
785 func (m *ServiceCIDRStatus) Size() (n int) {
786 if m == nil {
787 return 0
788 }
789 var l int
790 _ = l
791 if len(m.Conditions) > 0 {
792 for _, e := range m.Conditions {
793 l = e.Size()
794 n += 1 + l + sovGenerated(uint64(l))
795 }
796 }
797 return n
798 }
799
800 func sovGenerated(x uint64) (n int) {
801 return (math_bits.Len64(x|1) + 6) / 7
802 }
803 func sozGenerated(x uint64) (n int) {
804 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
805 }
806 func (this *IPAddress) String() string {
807 if this == nil {
808 return "nil"
809 }
810 s := strings.Join([]string{`&IPAddress{`,
811 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
812 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IPAddressSpec", "IPAddressSpec", 1), `&`, ``, 1) + `,`,
813 `}`,
814 }, "")
815 return s
816 }
817 func (this *IPAddressList) String() string {
818 if this == nil {
819 return "nil"
820 }
821 repeatedStringForItems := "[]IPAddress{"
822 for _, f := range this.Items {
823 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "IPAddress", "IPAddress", 1), `&`, ``, 1) + ","
824 }
825 repeatedStringForItems += "}"
826 s := strings.Join([]string{`&IPAddressList{`,
827 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
828 `Items:` + repeatedStringForItems + `,`,
829 `}`,
830 }, "")
831 return s
832 }
833 func (this *IPAddressSpec) String() string {
834 if this == nil {
835 return "nil"
836 }
837 s := strings.Join([]string{`&IPAddressSpec{`,
838 `ParentRef:` + strings.Replace(this.ParentRef.String(), "ParentReference", "ParentReference", 1) + `,`,
839 `}`,
840 }, "")
841 return s
842 }
843 func (this *ParentReference) String() string {
844 if this == nil {
845 return "nil"
846 }
847 s := strings.Join([]string{`&ParentReference{`,
848 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
849 `Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
850 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
851 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
852 `}`,
853 }, "")
854 return s
855 }
856 func (this *ServiceCIDR) String() string {
857 if this == nil {
858 return "nil"
859 }
860 s := strings.Join([]string{`&ServiceCIDR{`,
861 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
862 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ServiceCIDRSpec", "ServiceCIDRSpec", 1), `&`, ``, 1) + `,`,
863 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ServiceCIDRStatus", "ServiceCIDRStatus", 1), `&`, ``, 1) + `,`,
864 `}`,
865 }, "")
866 return s
867 }
868 func (this *ServiceCIDRList) String() string {
869 if this == nil {
870 return "nil"
871 }
872 repeatedStringForItems := "[]ServiceCIDR{"
873 for _, f := range this.Items {
874 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ServiceCIDR", "ServiceCIDR", 1), `&`, ``, 1) + ","
875 }
876 repeatedStringForItems += "}"
877 s := strings.Join([]string{`&ServiceCIDRList{`,
878 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
879 `Items:` + repeatedStringForItems + `,`,
880 `}`,
881 }, "")
882 return s
883 }
884 func (this *ServiceCIDRSpec) String() string {
885 if this == nil {
886 return "nil"
887 }
888 s := strings.Join([]string{`&ServiceCIDRSpec{`,
889 `CIDRs:` + fmt.Sprintf("%v", this.CIDRs) + `,`,
890 `}`,
891 }, "")
892 return s
893 }
894 func (this *ServiceCIDRStatus) String() string {
895 if this == nil {
896 return "nil"
897 }
898 repeatedStringForConditions := "[]Condition{"
899 for _, f := range this.Conditions {
900 repeatedStringForConditions += fmt.Sprintf("%v", f) + ","
901 }
902 repeatedStringForConditions += "}"
903 s := strings.Join([]string{`&ServiceCIDRStatus{`,
904 `Conditions:` + repeatedStringForConditions + `,`,
905 `}`,
906 }, "")
907 return s
908 }
909 func valueToStringGenerated(v interface{}) string {
910 rv := reflect.ValueOf(v)
911 if rv.IsNil() {
912 return "nil"
913 }
914 pv := reflect.Indirect(rv).Interface()
915 return fmt.Sprintf("*%v", pv)
916 }
917 func (m *IPAddress) Unmarshal(dAtA []byte) error {
918 l := len(dAtA)
919 iNdEx := 0
920 for iNdEx < l {
921 preIndex := iNdEx
922 var wire uint64
923 for shift := uint(0); ; shift += 7 {
924 if shift >= 64 {
925 return ErrIntOverflowGenerated
926 }
927 if iNdEx >= l {
928 return io.ErrUnexpectedEOF
929 }
930 b := dAtA[iNdEx]
931 iNdEx++
932 wire |= uint64(b&0x7F) << shift
933 if b < 0x80 {
934 break
935 }
936 }
937 fieldNum := int32(wire >> 3)
938 wireType := int(wire & 0x7)
939 if wireType == 4 {
940 return fmt.Errorf("proto: IPAddress: wiretype end group for non-group")
941 }
942 if fieldNum <= 0 {
943 return fmt.Errorf("proto: IPAddress: illegal tag %d (wire type %d)", fieldNum, wire)
944 }
945 switch fieldNum {
946 case 1:
947 if wireType != 2 {
948 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
949 }
950 var msglen int
951 for shift := uint(0); ; shift += 7 {
952 if shift >= 64 {
953 return ErrIntOverflowGenerated
954 }
955 if iNdEx >= l {
956 return io.ErrUnexpectedEOF
957 }
958 b := dAtA[iNdEx]
959 iNdEx++
960 msglen |= int(b&0x7F) << shift
961 if b < 0x80 {
962 break
963 }
964 }
965 if msglen < 0 {
966 return ErrInvalidLengthGenerated
967 }
968 postIndex := iNdEx + msglen
969 if postIndex < 0 {
970 return ErrInvalidLengthGenerated
971 }
972 if postIndex > l {
973 return io.ErrUnexpectedEOF
974 }
975 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
976 return err
977 }
978 iNdEx = postIndex
979 case 2:
980 if wireType != 2 {
981 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
982 }
983 var msglen int
984 for shift := uint(0); ; shift += 7 {
985 if shift >= 64 {
986 return ErrIntOverflowGenerated
987 }
988 if iNdEx >= l {
989 return io.ErrUnexpectedEOF
990 }
991 b := dAtA[iNdEx]
992 iNdEx++
993 msglen |= int(b&0x7F) << shift
994 if b < 0x80 {
995 break
996 }
997 }
998 if msglen < 0 {
999 return ErrInvalidLengthGenerated
1000 }
1001 postIndex := iNdEx + msglen
1002 if postIndex < 0 {
1003 return ErrInvalidLengthGenerated
1004 }
1005 if postIndex > l {
1006 return io.ErrUnexpectedEOF
1007 }
1008 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1009 return err
1010 }
1011 iNdEx = postIndex
1012 default:
1013 iNdEx = preIndex
1014 skippy, err := skipGenerated(dAtA[iNdEx:])
1015 if err != nil {
1016 return err
1017 }
1018 if (skippy < 0) || (iNdEx+skippy) < 0 {
1019 return ErrInvalidLengthGenerated
1020 }
1021 if (iNdEx + skippy) > l {
1022 return io.ErrUnexpectedEOF
1023 }
1024 iNdEx += skippy
1025 }
1026 }
1027
1028 if iNdEx > l {
1029 return io.ErrUnexpectedEOF
1030 }
1031 return nil
1032 }
1033 func (m *IPAddressList) Unmarshal(dAtA []byte) error {
1034 l := len(dAtA)
1035 iNdEx := 0
1036 for iNdEx < l {
1037 preIndex := iNdEx
1038 var wire uint64
1039 for shift := uint(0); ; shift += 7 {
1040 if shift >= 64 {
1041 return ErrIntOverflowGenerated
1042 }
1043 if iNdEx >= l {
1044 return io.ErrUnexpectedEOF
1045 }
1046 b := dAtA[iNdEx]
1047 iNdEx++
1048 wire |= uint64(b&0x7F) << shift
1049 if b < 0x80 {
1050 break
1051 }
1052 }
1053 fieldNum := int32(wire >> 3)
1054 wireType := int(wire & 0x7)
1055 if wireType == 4 {
1056 return fmt.Errorf("proto: IPAddressList: wiretype end group for non-group")
1057 }
1058 if fieldNum <= 0 {
1059 return fmt.Errorf("proto: IPAddressList: illegal tag %d (wire type %d)", fieldNum, wire)
1060 }
1061 switch fieldNum {
1062 case 1:
1063 if wireType != 2 {
1064 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1065 }
1066 var msglen int
1067 for shift := uint(0); ; shift += 7 {
1068 if shift >= 64 {
1069 return ErrIntOverflowGenerated
1070 }
1071 if iNdEx >= l {
1072 return io.ErrUnexpectedEOF
1073 }
1074 b := dAtA[iNdEx]
1075 iNdEx++
1076 msglen |= int(b&0x7F) << shift
1077 if b < 0x80 {
1078 break
1079 }
1080 }
1081 if msglen < 0 {
1082 return ErrInvalidLengthGenerated
1083 }
1084 postIndex := iNdEx + msglen
1085 if postIndex < 0 {
1086 return ErrInvalidLengthGenerated
1087 }
1088 if postIndex > l {
1089 return io.ErrUnexpectedEOF
1090 }
1091 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1092 return err
1093 }
1094 iNdEx = postIndex
1095 case 2:
1096 if wireType != 2 {
1097 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1098 }
1099 var msglen int
1100 for shift := uint(0); ; shift += 7 {
1101 if shift >= 64 {
1102 return ErrIntOverflowGenerated
1103 }
1104 if iNdEx >= l {
1105 return io.ErrUnexpectedEOF
1106 }
1107 b := dAtA[iNdEx]
1108 iNdEx++
1109 msglen |= int(b&0x7F) << shift
1110 if b < 0x80 {
1111 break
1112 }
1113 }
1114 if msglen < 0 {
1115 return ErrInvalidLengthGenerated
1116 }
1117 postIndex := iNdEx + msglen
1118 if postIndex < 0 {
1119 return ErrInvalidLengthGenerated
1120 }
1121 if postIndex > l {
1122 return io.ErrUnexpectedEOF
1123 }
1124 m.Items = append(m.Items, IPAddress{})
1125 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1126 return err
1127 }
1128 iNdEx = postIndex
1129 default:
1130 iNdEx = preIndex
1131 skippy, err := skipGenerated(dAtA[iNdEx:])
1132 if err != nil {
1133 return err
1134 }
1135 if (skippy < 0) || (iNdEx+skippy) < 0 {
1136 return ErrInvalidLengthGenerated
1137 }
1138 if (iNdEx + skippy) > l {
1139 return io.ErrUnexpectedEOF
1140 }
1141 iNdEx += skippy
1142 }
1143 }
1144
1145 if iNdEx > l {
1146 return io.ErrUnexpectedEOF
1147 }
1148 return nil
1149 }
1150 func (m *IPAddressSpec) Unmarshal(dAtA []byte) error {
1151 l := len(dAtA)
1152 iNdEx := 0
1153 for iNdEx < l {
1154 preIndex := iNdEx
1155 var wire uint64
1156 for shift := uint(0); ; shift += 7 {
1157 if shift >= 64 {
1158 return ErrIntOverflowGenerated
1159 }
1160 if iNdEx >= l {
1161 return io.ErrUnexpectedEOF
1162 }
1163 b := dAtA[iNdEx]
1164 iNdEx++
1165 wire |= uint64(b&0x7F) << shift
1166 if b < 0x80 {
1167 break
1168 }
1169 }
1170 fieldNum := int32(wire >> 3)
1171 wireType := int(wire & 0x7)
1172 if wireType == 4 {
1173 return fmt.Errorf("proto: IPAddressSpec: wiretype end group for non-group")
1174 }
1175 if fieldNum <= 0 {
1176 return fmt.Errorf("proto: IPAddressSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1177 }
1178 switch fieldNum {
1179 case 1:
1180 if wireType != 2 {
1181 return fmt.Errorf("proto: wrong wireType = %d for field ParentRef", wireType)
1182 }
1183 var msglen int
1184 for shift := uint(0); ; shift += 7 {
1185 if shift >= 64 {
1186 return ErrIntOverflowGenerated
1187 }
1188 if iNdEx >= l {
1189 return io.ErrUnexpectedEOF
1190 }
1191 b := dAtA[iNdEx]
1192 iNdEx++
1193 msglen |= int(b&0x7F) << shift
1194 if b < 0x80 {
1195 break
1196 }
1197 }
1198 if msglen < 0 {
1199 return ErrInvalidLengthGenerated
1200 }
1201 postIndex := iNdEx + msglen
1202 if postIndex < 0 {
1203 return ErrInvalidLengthGenerated
1204 }
1205 if postIndex > l {
1206 return io.ErrUnexpectedEOF
1207 }
1208 if m.ParentRef == nil {
1209 m.ParentRef = &ParentReference{}
1210 }
1211 if err := m.ParentRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1212 return err
1213 }
1214 iNdEx = postIndex
1215 default:
1216 iNdEx = preIndex
1217 skippy, err := skipGenerated(dAtA[iNdEx:])
1218 if err != nil {
1219 return err
1220 }
1221 if (skippy < 0) || (iNdEx+skippy) < 0 {
1222 return ErrInvalidLengthGenerated
1223 }
1224 if (iNdEx + skippy) > l {
1225 return io.ErrUnexpectedEOF
1226 }
1227 iNdEx += skippy
1228 }
1229 }
1230
1231 if iNdEx > l {
1232 return io.ErrUnexpectedEOF
1233 }
1234 return nil
1235 }
1236 func (m *ParentReference) Unmarshal(dAtA []byte) error {
1237 l := len(dAtA)
1238 iNdEx := 0
1239 for iNdEx < l {
1240 preIndex := iNdEx
1241 var wire uint64
1242 for shift := uint(0); ; shift += 7 {
1243 if shift >= 64 {
1244 return ErrIntOverflowGenerated
1245 }
1246 if iNdEx >= l {
1247 return io.ErrUnexpectedEOF
1248 }
1249 b := dAtA[iNdEx]
1250 iNdEx++
1251 wire |= uint64(b&0x7F) << shift
1252 if b < 0x80 {
1253 break
1254 }
1255 }
1256 fieldNum := int32(wire >> 3)
1257 wireType := int(wire & 0x7)
1258 if wireType == 4 {
1259 return fmt.Errorf("proto: ParentReference: wiretype end group for non-group")
1260 }
1261 if fieldNum <= 0 {
1262 return fmt.Errorf("proto: ParentReference: illegal tag %d (wire type %d)", fieldNum, wire)
1263 }
1264 switch fieldNum {
1265 case 1:
1266 if wireType != 2 {
1267 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
1268 }
1269 var stringLen uint64
1270 for shift := uint(0); ; shift += 7 {
1271 if shift >= 64 {
1272 return ErrIntOverflowGenerated
1273 }
1274 if iNdEx >= l {
1275 return io.ErrUnexpectedEOF
1276 }
1277 b := dAtA[iNdEx]
1278 iNdEx++
1279 stringLen |= uint64(b&0x7F) << shift
1280 if b < 0x80 {
1281 break
1282 }
1283 }
1284 intStringLen := int(stringLen)
1285 if intStringLen < 0 {
1286 return ErrInvalidLengthGenerated
1287 }
1288 postIndex := iNdEx + intStringLen
1289 if postIndex < 0 {
1290 return ErrInvalidLengthGenerated
1291 }
1292 if postIndex > l {
1293 return io.ErrUnexpectedEOF
1294 }
1295 m.Group = string(dAtA[iNdEx:postIndex])
1296 iNdEx = postIndex
1297 case 2:
1298 if wireType != 2 {
1299 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
1300 }
1301 var stringLen uint64
1302 for shift := uint(0); ; shift += 7 {
1303 if shift >= 64 {
1304 return ErrIntOverflowGenerated
1305 }
1306 if iNdEx >= l {
1307 return io.ErrUnexpectedEOF
1308 }
1309 b := dAtA[iNdEx]
1310 iNdEx++
1311 stringLen |= uint64(b&0x7F) << shift
1312 if b < 0x80 {
1313 break
1314 }
1315 }
1316 intStringLen := int(stringLen)
1317 if intStringLen < 0 {
1318 return ErrInvalidLengthGenerated
1319 }
1320 postIndex := iNdEx + intStringLen
1321 if postIndex < 0 {
1322 return ErrInvalidLengthGenerated
1323 }
1324 if postIndex > l {
1325 return io.ErrUnexpectedEOF
1326 }
1327 m.Resource = string(dAtA[iNdEx:postIndex])
1328 iNdEx = postIndex
1329 case 3:
1330 if wireType != 2 {
1331 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", 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 m.Namespace = string(dAtA[iNdEx:postIndex])
1360 iNdEx = postIndex
1361 case 4:
1362 if wireType != 2 {
1363 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
1364 }
1365 var stringLen uint64
1366 for shift := uint(0); ; shift += 7 {
1367 if shift >= 64 {
1368 return ErrIntOverflowGenerated
1369 }
1370 if iNdEx >= l {
1371 return io.ErrUnexpectedEOF
1372 }
1373 b := dAtA[iNdEx]
1374 iNdEx++
1375 stringLen |= uint64(b&0x7F) << shift
1376 if b < 0x80 {
1377 break
1378 }
1379 }
1380 intStringLen := int(stringLen)
1381 if intStringLen < 0 {
1382 return ErrInvalidLengthGenerated
1383 }
1384 postIndex := iNdEx + intStringLen
1385 if postIndex < 0 {
1386 return ErrInvalidLengthGenerated
1387 }
1388 if postIndex > l {
1389 return io.ErrUnexpectedEOF
1390 }
1391 m.Name = string(dAtA[iNdEx:postIndex])
1392 iNdEx = postIndex
1393 default:
1394 iNdEx = preIndex
1395 skippy, err := skipGenerated(dAtA[iNdEx:])
1396 if err != nil {
1397 return err
1398 }
1399 if (skippy < 0) || (iNdEx+skippy) < 0 {
1400 return ErrInvalidLengthGenerated
1401 }
1402 if (iNdEx + skippy) > l {
1403 return io.ErrUnexpectedEOF
1404 }
1405 iNdEx += skippy
1406 }
1407 }
1408
1409 if iNdEx > l {
1410 return io.ErrUnexpectedEOF
1411 }
1412 return nil
1413 }
1414 func (m *ServiceCIDR) Unmarshal(dAtA []byte) error {
1415 l := len(dAtA)
1416 iNdEx := 0
1417 for iNdEx < l {
1418 preIndex := iNdEx
1419 var wire uint64
1420 for shift := uint(0); ; shift += 7 {
1421 if shift >= 64 {
1422 return ErrIntOverflowGenerated
1423 }
1424 if iNdEx >= l {
1425 return io.ErrUnexpectedEOF
1426 }
1427 b := dAtA[iNdEx]
1428 iNdEx++
1429 wire |= uint64(b&0x7F) << shift
1430 if b < 0x80 {
1431 break
1432 }
1433 }
1434 fieldNum := int32(wire >> 3)
1435 wireType := int(wire & 0x7)
1436 if wireType == 4 {
1437 return fmt.Errorf("proto: ServiceCIDR: wiretype end group for non-group")
1438 }
1439 if fieldNum <= 0 {
1440 return fmt.Errorf("proto: ServiceCIDR: illegal tag %d (wire type %d)", fieldNum, wire)
1441 }
1442 switch fieldNum {
1443 case 1:
1444 if wireType != 2 {
1445 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1446 }
1447 var msglen int
1448 for shift := uint(0); ; shift += 7 {
1449 if shift >= 64 {
1450 return ErrIntOverflowGenerated
1451 }
1452 if iNdEx >= l {
1453 return io.ErrUnexpectedEOF
1454 }
1455 b := dAtA[iNdEx]
1456 iNdEx++
1457 msglen |= int(b&0x7F) << shift
1458 if b < 0x80 {
1459 break
1460 }
1461 }
1462 if msglen < 0 {
1463 return ErrInvalidLengthGenerated
1464 }
1465 postIndex := iNdEx + msglen
1466 if postIndex < 0 {
1467 return ErrInvalidLengthGenerated
1468 }
1469 if postIndex > l {
1470 return io.ErrUnexpectedEOF
1471 }
1472 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1473 return err
1474 }
1475 iNdEx = postIndex
1476 case 2:
1477 if wireType != 2 {
1478 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
1479 }
1480 var msglen int
1481 for shift := uint(0); ; shift += 7 {
1482 if shift >= 64 {
1483 return ErrIntOverflowGenerated
1484 }
1485 if iNdEx >= l {
1486 return io.ErrUnexpectedEOF
1487 }
1488 b := dAtA[iNdEx]
1489 iNdEx++
1490 msglen |= int(b&0x7F) << shift
1491 if b < 0x80 {
1492 break
1493 }
1494 }
1495 if msglen < 0 {
1496 return ErrInvalidLengthGenerated
1497 }
1498 postIndex := iNdEx + msglen
1499 if postIndex < 0 {
1500 return ErrInvalidLengthGenerated
1501 }
1502 if postIndex > l {
1503 return io.ErrUnexpectedEOF
1504 }
1505 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1506 return err
1507 }
1508 iNdEx = postIndex
1509 case 3:
1510 if wireType != 2 {
1511 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
1512 }
1513 var msglen int
1514 for shift := uint(0); ; shift += 7 {
1515 if shift >= 64 {
1516 return ErrIntOverflowGenerated
1517 }
1518 if iNdEx >= l {
1519 return io.ErrUnexpectedEOF
1520 }
1521 b := dAtA[iNdEx]
1522 iNdEx++
1523 msglen |= int(b&0x7F) << shift
1524 if b < 0x80 {
1525 break
1526 }
1527 }
1528 if msglen < 0 {
1529 return ErrInvalidLengthGenerated
1530 }
1531 postIndex := iNdEx + msglen
1532 if postIndex < 0 {
1533 return ErrInvalidLengthGenerated
1534 }
1535 if postIndex > l {
1536 return io.ErrUnexpectedEOF
1537 }
1538 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1539 return err
1540 }
1541 iNdEx = postIndex
1542 default:
1543 iNdEx = preIndex
1544 skippy, err := skipGenerated(dAtA[iNdEx:])
1545 if err != nil {
1546 return err
1547 }
1548 if (skippy < 0) || (iNdEx+skippy) < 0 {
1549 return ErrInvalidLengthGenerated
1550 }
1551 if (iNdEx + skippy) > l {
1552 return io.ErrUnexpectedEOF
1553 }
1554 iNdEx += skippy
1555 }
1556 }
1557
1558 if iNdEx > l {
1559 return io.ErrUnexpectedEOF
1560 }
1561 return nil
1562 }
1563 func (m *ServiceCIDRList) Unmarshal(dAtA []byte) error {
1564 l := len(dAtA)
1565 iNdEx := 0
1566 for iNdEx < l {
1567 preIndex := iNdEx
1568 var wire uint64
1569 for shift := uint(0); ; shift += 7 {
1570 if shift >= 64 {
1571 return ErrIntOverflowGenerated
1572 }
1573 if iNdEx >= l {
1574 return io.ErrUnexpectedEOF
1575 }
1576 b := dAtA[iNdEx]
1577 iNdEx++
1578 wire |= uint64(b&0x7F) << shift
1579 if b < 0x80 {
1580 break
1581 }
1582 }
1583 fieldNum := int32(wire >> 3)
1584 wireType := int(wire & 0x7)
1585 if wireType == 4 {
1586 return fmt.Errorf("proto: ServiceCIDRList: wiretype end group for non-group")
1587 }
1588 if fieldNum <= 0 {
1589 return fmt.Errorf("proto: ServiceCIDRList: illegal tag %d (wire type %d)", fieldNum, wire)
1590 }
1591 switch fieldNum {
1592 case 1:
1593 if wireType != 2 {
1594 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1595 }
1596 var msglen int
1597 for shift := uint(0); ; shift += 7 {
1598 if shift >= 64 {
1599 return ErrIntOverflowGenerated
1600 }
1601 if iNdEx >= l {
1602 return io.ErrUnexpectedEOF
1603 }
1604 b := dAtA[iNdEx]
1605 iNdEx++
1606 msglen |= int(b&0x7F) << shift
1607 if b < 0x80 {
1608 break
1609 }
1610 }
1611 if msglen < 0 {
1612 return ErrInvalidLengthGenerated
1613 }
1614 postIndex := iNdEx + msglen
1615 if postIndex < 0 {
1616 return ErrInvalidLengthGenerated
1617 }
1618 if postIndex > l {
1619 return io.ErrUnexpectedEOF
1620 }
1621 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1622 return err
1623 }
1624 iNdEx = postIndex
1625 case 2:
1626 if wireType != 2 {
1627 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1628 }
1629 var msglen int
1630 for shift := uint(0); ; shift += 7 {
1631 if shift >= 64 {
1632 return ErrIntOverflowGenerated
1633 }
1634 if iNdEx >= l {
1635 return io.ErrUnexpectedEOF
1636 }
1637 b := dAtA[iNdEx]
1638 iNdEx++
1639 msglen |= int(b&0x7F) << shift
1640 if b < 0x80 {
1641 break
1642 }
1643 }
1644 if msglen < 0 {
1645 return ErrInvalidLengthGenerated
1646 }
1647 postIndex := iNdEx + msglen
1648 if postIndex < 0 {
1649 return ErrInvalidLengthGenerated
1650 }
1651 if postIndex > l {
1652 return io.ErrUnexpectedEOF
1653 }
1654 m.Items = append(m.Items, ServiceCIDR{})
1655 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1656 return err
1657 }
1658 iNdEx = postIndex
1659 default:
1660 iNdEx = preIndex
1661 skippy, err := skipGenerated(dAtA[iNdEx:])
1662 if err != nil {
1663 return err
1664 }
1665 if (skippy < 0) || (iNdEx+skippy) < 0 {
1666 return ErrInvalidLengthGenerated
1667 }
1668 if (iNdEx + skippy) > l {
1669 return io.ErrUnexpectedEOF
1670 }
1671 iNdEx += skippy
1672 }
1673 }
1674
1675 if iNdEx > l {
1676 return io.ErrUnexpectedEOF
1677 }
1678 return nil
1679 }
1680 func (m *ServiceCIDRSpec) Unmarshal(dAtA []byte) error {
1681 l := len(dAtA)
1682 iNdEx := 0
1683 for iNdEx < l {
1684 preIndex := iNdEx
1685 var wire uint64
1686 for shift := uint(0); ; shift += 7 {
1687 if shift >= 64 {
1688 return ErrIntOverflowGenerated
1689 }
1690 if iNdEx >= l {
1691 return io.ErrUnexpectedEOF
1692 }
1693 b := dAtA[iNdEx]
1694 iNdEx++
1695 wire |= uint64(b&0x7F) << shift
1696 if b < 0x80 {
1697 break
1698 }
1699 }
1700 fieldNum := int32(wire >> 3)
1701 wireType := int(wire & 0x7)
1702 if wireType == 4 {
1703 return fmt.Errorf("proto: ServiceCIDRSpec: wiretype end group for non-group")
1704 }
1705 if fieldNum <= 0 {
1706 return fmt.Errorf("proto: ServiceCIDRSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1707 }
1708 switch fieldNum {
1709 case 1:
1710 if wireType != 2 {
1711 return fmt.Errorf("proto: wrong wireType = %d for field CIDRs", wireType)
1712 }
1713 var stringLen uint64
1714 for shift := uint(0); ; shift += 7 {
1715 if shift >= 64 {
1716 return ErrIntOverflowGenerated
1717 }
1718 if iNdEx >= l {
1719 return io.ErrUnexpectedEOF
1720 }
1721 b := dAtA[iNdEx]
1722 iNdEx++
1723 stringLen |= uint64(b&0x7F) << shift
1724 if b < 0x80 {
1725 break
1726 }
1727 }
1728 intStringLen := int(stringLen)
1729 if intStringLen < 0 {
1730 return ErrInvalidLengthGenerated
1731 }
1732 postIndex := iNdEx + intStringLen
1733 if postIndex < 0 {
1734 return ErrInvalidLengthGenerated
1735 }
1736 if postIndex > l {
1737 return io.ErrUnexpectedEOF
1738 }
1739 m.CIDRs = append(m.CIDRs, string(dAtA[iNdEx:postIndex]))
1740 iNdEx = postIndex
1741 default:
1742 iNdEx = preIndex
1743 skippy, err := skipGenerated(dAtA[iNdEx:])
1744 if err != nil {
1745 return err
1746 }
1747 if (skippy < 0) || (iNdEx+skippy) < 0 {
1748 return ErrInvalidLengthGenerated
1749 }
1750 if (iNdEx + skippy) > l {
1751 return io.ErrUnexpectedEOF
1752 }
1753 iNdEx += skippy
1754 }
1755 }
1756
1757 if iNdEx > l {
1758 return io.ErrUnexpectedEOF
1759 }
1760 return nil
1761 }
1762 func (m *ServiceCIDRStatus) Unmarshal(dAtA []byte) error {
1763 l := len(dAtA)
1764 iNdEx := 0
1765 for iNdEx < l {
1766 preIndex := iNdEx
1767 var wire uint64
1768 for shift := uint(0); ; shift += 7 {
1769 if shift >= 64 {
1770 return ErrIntOverflowGenerated
1771 }
1772 if iNdEx >= l {
1773 return io.ErrUnexpectedEOF
1774 }
1775 b := dAtA[iNdEx]
1776 iNdEx++
1777 wire |= uint64(b&0x7F) << shift
1778 if b < 0x80 {
1779 break
1780 }
1781 }
1782 fieldNum := int32(wire >> 3)
1783 wireType := int(wire & 0x7)
1784 if wireType == 4 {
1785 return fmt.Errorf("proto: ServiceCIDRStatus: wiretype end group for non-group")
1786 }
1787 if fieldNum <= 0 {
1788 return fmt.Errorf("proto: ServiceCIDRStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1789 }
1790 switch fieldNum {
1791 case 1:
1792 if wireType != 2 {
1793 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
1794 }
1795 var msglen int
1796 for shift := uint(0); ; shift += 7 {
1797 if shift >= 64 {
1798 return ErrIntOverflowGenerated
1799 }
1800 if iNdEx >= l {
1801 return io.ErrUnexpectedEOF
1802 }
1803 b := dAtA[iNdEx]
1804 iNdEx++
1805 msglen |= int(b&0x7F) << shift
1806 if b < 0x80 {
1807 break
1808 }
1809 }
1810 if msglen < 0 {
1811 return ErrInvalidLengthGenerated
1812 }
1813 postIndex := iNdEx + msglen
1814 if postIndex < 0 {
1815 return ErrInvalidLengthGenerated
1816 }
1817 if postIndex > l {
1818 return io.ErrUnexpectedEOF
1819 }
1820 m.Conditions = append(m.Conditions, v1.Condition{})
1821 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1822 return err
1823 }
1824 iNdEx = postIndex
1825 default:
1826 iNdEx = preIndex
1827 skippy, err := skipGenerated(dAtA[iNdEx:])
1828 if err != nil {
1829 return err
1830 }
1831 if (skippy < 0) || (iNdEx+skippy) < 0 {
1832 return ErrInvalidLengthGenerated
1833 }
1834 if (iNdEx + skippy) > l {
1835 return io.ErrUnexpectedEOF
1836 }
1837 iNdEx += skippy
1838 }
1839 }
1840
1841 if iNdEx > l {
1842 return io.ErrUnexpectedEOF
1843 }
1844 return nil
1845 }
1846 func skipGenerated(dAtA []byte) (n int, err error) {
1847 l := len(dAtA)
1848 iNdEx := 0
1849 depth := 0
1850 for iNdEx < l {
1851 var wire uint64
1852 for shift := uint(0); ; shift += 7 {
1853 if shift >= 64 {
1854 return 0, ErrIntOverflowGenerated
1855 }
1856 if iNdEx >= l {
1857 return 0, io.ErrUnexpectedEOF
1858 }
1859 b := dAtA[iNdEx]
1860 iNdEx++
1861 wire |= (uint64(b) & 0x7F) << shift
1862 if b < 0x80 {
1863 break
1864 }
1865 }
1866 wireType := int(wire & 0x7)
1867 switch wireType {
1868 case 0:
1869 for shift := uint(0); ; shift += 7 {
1870 if shift >= 64 {
1871 return 0, ErrIntOverflowGenerated
1872 }
1873 if iNdEx >= l {
1874 return 0, io.ErrUnexpectedEOF
1875 }
1876 iNdEx++
1877 if dAtA[iNdEx-1] < 0x80 {
1878 break
1879 }
1880 }
1881 case 1:
1882 iNdEx += 8
1883 case 2:
1884 var length int
1885 for shift := uint(0); ; shift += 7 {
1886 if shift >= 64 {
1887 return 0, ErrIntOverflowGenerated
1888 }
1889 if iNdEx >= l {
1890 return 0, io.ErrUnexpectedEOF
1891 }
1892 b := dAtA[iNdEx]
1893 iNdEx++
1894 length |= (int(b) & 0x7F) << shift
1895 if b < 0x80 {
1896 break
1897 }
1898 }
1899 if length < 0 {
1900 return 0, ErrInvalidLengthGenerated
1901 }
1902 iNdEx += length
1903 case 3:
1904 depth++
1905 case 4:
1906 if depth == 0 {
1907 return 0, ErrUnexpectedEndOfGroupGenerated
1908 }
1909 depth--
1910 case 5:
1911 iNdEx += 4
1912 default:
1913 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1914 }
1915 if iNdEx < 0 {
1916 return 0, ErrInvalidLengthGenerated
1917 }
1918 if depth == 0 {
1919 return iNdEx, nil
1920 }
1921 }
1922 return 0, io.ErrUnexpectedEOF
1923 }
1924
1925 var (
1926 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1927 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
1928 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
1929 )
1930
View as plain text