1
2
3
4 package v1
5
6 import (
7 fmt "fmt"
8
9 io "io"
10
11 proto "github.com/gogo/protobuf/proto"
12 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
13
14 math "math"
15 math_bits "math/bits"
16 reflect "reflect"
17 strings "strings"
18 )
19
20
21 var _ = proto.Marshal
22 var _ = fmt.Errorf
23 var _ = math.Inf
24
25
26
27
28
29 const _ = proto.GoGoProtoPackageIsVersion3
30
31 func (m *CloudPrivateIPConfig) Reset() { *m = CloudPrivateIPConfig{} }
32 func (*CloudPrivateIPConfig) ProtoMessage() {}
33 func (*CloudPrivateIPConfig) Descriptor() ([]byte, []int) {
34 return fileDescriptor_454253a7ab01c6d0, []int{0}
35 }
36 func (m *CloudPrivateIPConfig) XXX_Unmarshal(b []byte) error {
37 return m.Unmarshal(b)
38 }
39 func (m *CloudPrivateIPConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
40 b = b[:cap(b)]
41 n, err := m.MarshalToSizedBuffer(b)
42 if err != nil {
43 return nil, err
44 }
45 return b[:n], nil
46 }
47 func (m *CloudPrivateIPConfig) XXX_Merge(src proto.Message) {
48 xxx_messageInfo_CloudPrivateIPConfig.Merge(m, src)
49 }
50 func (m *CloudPrivateIPConfig) XXX_Size() int {
51 return m.Size()
52 }
53 func (m *CloudPrivateIPConfig) XXX_DiscardUnknown() {
54 xxx_messageInfo_CloudPrivateIPConfig.DiscardUnknown(m)
55 }
56
57 var xxx_messageInfo_CloudPrivateIPConfig proto.InternalMessageInfo
58
59 func (m *CloudPrivateIPConfigList) Reset() { *m = CloudPrivateIPConfigList{} }
60 func (*CloudPrivateIPConfigList) ProtoMessage() {}
61 func (*CloudPrivateIPConfigList) Descriptor() ([]byte, []int) {
62 return fileDescriptor_454253a7ab01c6d0, []int{1}
63 }
64 func (m *CloudPrivateIPConfigList) XXX_Unmarshal(b []byte) error {
65 return m.Unmarshal(b)
66 }
67 func (m *CloudPrivateIPConfigList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
68 b = b[:cap(b)]
69 n, err := m.MarshalToSizedBuffer(b)
70 if err != nil {
71 return nil, err
72 }
73 return b[:n], nil
74 }
75 func (m *CloudPrivateIPConfigList) XXX_Merge(src proto.Message) {
76 xxx_messageInfo_CloudPrivateIPConfigList.Merge(m, src)
77 }
78 func (m *CloudPrivateIPConfigList) XXX_Size() int {
79 return m.Size()
80 }
81 func (m *CloudPrivateIPConfigList) XXX_DiscardUnknown() {
82 xxx_messageInfo_CloudPrivateIPConfigList.DiscardUnknown(m)
83 }
84
85 var xxx_messageInfo_CloudPrivateIPConfigList proto.InternalMessageInfo
86
87 func (m *CloudPrivateIPConfigSpec) Reset() { *m = CloudPrivateIPConfigSpec{} }
88 func (*CloudPrivateIPConfigSpec) ProtoMessage() {}
89 func (*CloudPrivateIPConfigSpec) Descriptor() ([]byte, []int) {
90 return fileDescriptor_454253a7ab01c6d0, []int{2}
91 }
92 func (m *CloudPrivateIPConfigSpec) XXX_Unmarshal(b []byte) error {
93 return m.Unmarshal(b)
94 }
95 func (m *CloudPrivateIPConfigSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
96 b = b[:cap(b)]
97 n, err := m.MarshalToSizedBuffer(b)
98 if err != nil {
99 return nil, err
100 }
101 return b[:n], nil
102 }
103 func (m *CloudPrivateIPConfigSpec) XXX_Merge(src proto.Message) {
104 xxx_messageInfo_CloudPrivateIPConfigSpec.Merge(m, src)
105 }
106 func (m *CloudPrivateIPConfigSpec) XXX_Size() int {
107 return m.Size()
108 }
109 func (m *CloudPrivateIPConfigSpec) XXX_DiscardUnknown() {
110 xxx_messageInfo_CloudPrivateIPConfigSpec.DiscardUnknown(m)
111 }
112
113 var xxx_messageInfo_CloudPrivateIPConfigSpec proto.InternalMessageInfo
114
115 func (m *CloudPrivateIPConfigStatus) Reset() { *m = CloudPrivateIPConfigStatus{} }
116 func (*CloudPrivateIPConfigStatus) ProtoMessage() {}
117 func (*CloudPrivateIPConfigStatus) Descriptor() ([]byte, []int) {
118 return fileDescriptor_454253a7ab01c6d0, []int{3}
119 }
120 func (m *CloudPrivateIPConfigStatus) XXX_Unmarshal(b []byte) error {
121 return m.Unmarshal(b)
122 }
123 func (m *CloudPrivateIPConfigStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
124 b = b[:cap(b)]
125 n, err := m.MarshalToSizedBuffer(b)
126 if err != nil {
127 return nil, err
128 }
129 return b[:n], nil
130 }
131 func (m *CloudPrivateIPConfigStatus) XXX_Merge(src proto.Message) {
132 xxx_messageInfo_CloudPrivateIPConfigStatus.Merge(m, src)
133 }
134 func (m *CloudPrivateIPConfigStatus) XXX_Size() int {
135 return m.Size()
136 }
137 func (m *CloudPrivateIPConfigStatus) XXX_DiscardUnknown() {
138 xxx_messageInfo_CloudPrivateIPConfigStatus.DiscardUnknown(m)
139 }
140
141 var xxx_messageInfo_CloudPrivateIPConfigStatus proto.InternalMessageInfo
142
143 func init() {
144 proto.RegisterType((*CloudPrivateIPConfig)(nil), "github.com.openshift.api.cloudnetwork.v1.CloudPrivateIPConfig")
145 proto.RegisterType((*CloudPrivateIPConfigList)(nil), "github.com.openshift.api.cloudnetwork.v1.CloudPrivateIPConfigList")
146 proto.RegisterType((*CloudPrivateIPConfigSpec)(nil), "github.com.openshift.api.cloudnetwork.v1.CloudPrivateIPConfigSpec")
147 proto.RegisterType((*CloudPrivateIPConfigStatus)(nil), "github.com.openshift.api.cloudnetwork.v1.CloudPrivateIPConfigStatus")
148 }
149
150 func init() {
151 proto.RegisterFile("github.com/openshift/api/cloudnetwork/v1/generated.proto", fileDescriptor_454253a7ab01c6d0)
152 }
153
154 var fileDescriptor_454253a7ab01c6d0 = []byte{
155
156 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0xc1, 0x6e, 0xd3, 0x30,
157 0x18, 0xc7, 0xe3, 0xae, 0x9b, 0x86, 0x07, 0x08, 0x45, 0x1c, 0xa2, 0x1e, 0xbc, 0xaa, 0xa7, 0x5e,
158 0xb0, 0xe9, 0x84, 0xd0, 0x0e, 0x88, 0x43, 0xca, 0x65, 0x12, 0x8c, 0x29, 0xdc, 0x10, 0x07, 0x5c,
159 0xc7, 0x4d, 0x4d, 0x17, 0x3b, 0x8a, 0x9d, 0x22, 0x6e, 0x3c, 0x02, 0xef, 0xc0, 0xcb, 0xf4, 0xc0,
160 0x61, 0xc7, 0x5d, 0x98, 0x68, 0x78, 0x11, 0x64, 0x37, 0x6d, 0x23, 0xd6, 0x69, 0x91, 0x7a, 0xcb,
161 0xf7, 0x25, 0xff, 0xff, 0xef, 0xfb, 0xfe, 0x8e, 0x0c, 0x4f, 0x13, 0x61, 0x26, 0xc5, 0x08, 0x33,
162 0x95, 0x12, 0x95, 0x71, 0xa9, 0x27, 0x62, 0x6c, 0x08, 0xcd, 0x04, 0x61, 0x97, 0xaa, 0x88, 0x25,
163 0x37, 0x5f, 0x55, 0x3e, 0x25, 0xb3, 0x01, 0x49, 0xb8, 0xe4, 0x39, 0x35, 0x3c, 0xc6, 0x59, 0xae,
164 0x8c, 0xf2, 0xfb, 0x1b, 0x25, 0x5e, 0x2b, 0x31, 0xcd, 0x04, 0xae, 0x2b, 0xf1, 0x6c, 0xd0, 0x79,
165 0x56, 0x63, 0x24, 0x2a, 0x51, 0xc4, 0x19, 0x8c, 0x8a, 0xb1, 0xab, 0x5c, 0xe1, 0x9e, 0x96, 0xc6,
166 0x9d, 0x17, 0xd3, 0x53, 0x8d, 0x85, 0xb2, 0x43, 0xa4, 0x94, 0x4d, 0x84, 0xe4, 0xf9, 0x37, 0x92,
167 0x4d, 0x13, 0xdb, 0xd0, 0x24, 0xe5, 0x86, 0x6e, 0x19, 0xa7, 0x43, 0xee, 0x52, 0xe5, 0x85, 0x34,
168 0x22, 0xe5, 0xb7, 0x04, 0x2f, 0xef, 0x13, 0x68, 0x36, 0xe1, 0x29, 0xfd, 0x5f, 0xd7, 0xfb, 0xd5,
169 0x82, 0x4f, 0x87, 0x76, 0xc3, 0x8b, 0x5c, 0xcc, 0xa8, 0xe1, 0x67, 0x17, 0x43, 0x25, 0xc7, 0x22,
170 0xf1, 0x3f, 0xc3, 0x43, 0x3b, 0x5c, 0x4c, 0x0d, 0x0d, 0x40, 0x17, 0xf4, 0x8f, 0x4e, 0x9e, 0xe3,
171 0x25, 0x03, 0xd7, 0x19, 0x38, 0x9b, 0x26, 0xb6, 0xa1, 0xb1, 0xfd, 0x1a, 0xcf, 0x06, 0xf8, 0xfd,
172 0xe8, 0x0b, 0x67, 0xe6, 0x1d, 0x37, 0x34, 0xf4, 0xe7, 0x37, 0xc7, 0x5e, 0x79, 0x73, 0x0c, 0x37,
173 0xbd, 0x68, 0xed, 0xea, 0xc7, 0xb0, 0xad, 0x33, 0xce, 0x82, 0x96, 0x73, 0x0f, 0x71, 0xd3, 0x13,
174 0xc0, 0xdb, 0xe6, 0xfd, 0x90, 0x71, 0x16, 0x3e, 0xac, 0x78, 0x6d, 0x5b, 0x45, 0xce, 0xdd, 0xbf,
175 0x84, 0x07, 0xda, 0x50, 0x53, 0xe8, 0x60, 0xcf, 0x71, 0xde, 0xec, 0xc8, 0x71, 0x5e, 0xe1, 0xe3,
176 0x8a, 0x74, 0xb0, 0xac, 0xa3, 0x8a, 0xd1, 0xfb, 0x0d, 0x60, 0xb0, 0x4d, 0xf6, 0x56, 0x68, 0xe3,
177 0x7f, 0xba, 0x15, 0x29, 0x6e, 0x16, 0xa9, 0x55, 0xbb, 0x40, 0x9f, 0x54, 0xd8, 0xc3, 0x55, 0xa7,
178 0x16, 0x27, 0x83, 0xfb, 0xc2, 0xf0, 0x54, 0x07, 0xad, 0xee, 0x5e, 0xff, 0xe8, 0xe4, 0xf5, 0x6e,
179 0x7b, 0x86, 0x8f, 0x2a, 0xd4, 0xfe, 0x99, 0x35, 0x8d, 0x96, 0xde, 0xbd, 0x57, 0xdb, 0xd7, 0xb3,
180 0x79, 0xfb, 0x5d, 0xd8, 0x96, 0x2a, 0xe6, 0x6e, 0xb5, 0x07, 0x9b, 0xb3, 0x38, 0x57, 0x31, 0x8f,
181 0xdc, 0x9b, 0xde, 0x4f, 0x00, 0x3b, 0x77, 0x87, 0x7a, 0xbf, 0x81, 0xcf, 0x20, 0x64, 0x4a, 0xc6,
182 0xc2, 0x08, 0x25, 0x57, 0x8b, 0x92, 0x66, 0x19, 0x0e, 0x57, 0xba, 0xcd, 0x5f, 0xb9, 0x6e, 0xe9,
183 0xa8, 0x66, 0x1b, 0x9e, 0xcf, 0x17, 0xc8, 0xbb, 0x5a, 0x20, 0xef, 0x7a, 0x81, 0xbc, 0xef, 0x25,
184 0x02, 0xf3, 0x12, 0x81, 0xab, 0x12, 0x81, 0xeb, 0x12, 0x81, 0x3f, 0x25, 0x02, 0x3f, 0xfe, 0x22,
185 0xef, 0x63, 0xbf, 0xe9, 0x55, 0xf3, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xc8, 0xf0, 0xc5, 0x6e, 0x95,
186 0x04, 0x00, 0x00,
187 }
188
189 func (m *CloudPrivateIPConfig) Marshal() (dAtA []byte, err error) {
190 size := m.Size()
191 dAtA = make([]byte, size)
192 n, err := m.MarshalToSizedBuffer(dAtA[:size])
193 if err != nil {
194 return nil, err
195 }
196 return dAtA[:n], nil
197 }
198
199 func (m *CloudPrivateIPConfig) MarshalTo(dAtA []byte) (int, error) {
200 size := m.Size()
201 return m.MarshalToSizedBuffer(dAtA[:size])
202 }
203
204 func (m *CloudPrivateIPConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
205 i := len(dAtA)
206 _ = i
207 var l int
208 _ = l
209 {
210 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
211 if err != nil {
212 return 0, err
213 }
214 i -= size
215 i = encodeVarintGenerated(dAtA, i, uint64(size))
216 }
217 i--
218 dAtA[i] = 0x1a
219 {
220 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
221 if err != nil {
222 return 0, err
223 }
224 i -= size
225 i = encodeVarintGenerated(dAtA, i, uint64(size))
226 }
227 i--
228 dAtA[i] = 0x12
229 {
230 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
231 if err != nil {
232 return 0, err
233 }
234 i -= size
235 i = encodeVarintGenerated(dAtA, i, uint64(size))
236 }
237 i--
238 dAtA[i] = 0xa
239 return len(dAtA) - i, nil
240 }
241
242 func (m *CloudPrivateIPConfigList) Marshal() (dAtA []byte, err error) {
243 size := m.Size()
244 dAtA = make([]byte, size)
245 n, err := m.MarshalToSizedBuffer(dAtA[:size])
246 if err != nil {
247 return nil, err
248 }
249 return dAtA[:n], nil
250 }
251
252 func (m *CloudPrivateIPConfigList) MarshalTo(dAtA []byte) (int, error) {
253 size := m.Size()
254 return m.MarshalToSizedBuffer(dAtA[:size])
255 }
256
257 func (m *CloudPrivateIPConfigList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
258 i := len(dAtA)
259 _ = i
260 var l int
261 _ = l
262 if len(m.Items) > 0 {
263 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
264 {
265 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
266 if err != nil {
267 return 0, err
268 }
269 i -= size
270 i = encodeVarintGenerated(dAtA, i, uint64(size))
271 }
272 i--
273 dAtA[i] = 0x12
274 }
275 }
276 {
277 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
278 if err != nil {
279 return 0, err
280 }
281 i -= size
282 i = encodeVarintGenerated(dAtA, i, uint64(size))
283 }
284 i--
285 dAtA[i] = 0xa
286 return len(dAtA) - i, nil
287 }
288
289 func (m *CloudPrivateIPConfigSpec) Marshal() (dAtA []byte, err error) {
290 size := m.Size()
291 dAtA = make([]byte, size)
292 n, err := m.MarshalToSizedBuffer(dAtA[:size])
293 if err != nil {
294 return nil, err
295 }
296 return dAtA[:n], nil
297 }
298
299 func (m *CloudPrivateIPConfigSpec) MarshalTo(dAtA []byte) (int, error) {
300 size := m.Size()
301 return m.MarshalToSizedBuffer(dAtA[:size])
302 }
303
304 func (m *CloudPrivateIPConfigSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
305 i := len(dAtA)
306 _ = i
307 var l int
308 _ = l
309 i -= len(m.Node)
310 copy(dAtA[i:], m.Node)
311 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Node)))
312 i--
313 dAtA[i] = 0xa
314 return len(dAtA) - i, nil
315 }
316
317 func (m *CloudPrivateIPConfigStatus) Marshal() (dAtA []byte, err error) {
318 size := m.Size()
319 dAtA = make([]byte, size)
320 n, err := m.MarshalToSizedBuffer(dAtA[:size])
321 if err != nil {
322 return nil, err
323 }
324 return dAtA[:n], nil
325 }
326
327 func (m *CloudPrivateIPConfigStatus) MarshalTo(dAtA []byte) (int, error) {
328 size := m.Size()
329 return m.MarshalToSizedBuffer(dAtA[:size])
330 }
331
332 func (m *CloudPrivateIPConfigStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
333 i := len(dAtA)
334 _ = i
335 var l int
336 _ = l
337 if len(m.Conditions) > 0 {
338 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
339 {
340 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
341 if err != nil {
342 return 0, err
343 }
344 i -= size
345 i = encodeVarintGenerated(dAtA, i, uint64(size))
346 }
347 i--
348 dAtA[i] = 0x12
349 }
350 }
351 i -= len(m.Node)
352 copy(dAtA[i:], m.Node)
353 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Node)))
354 i--
355 dAtA[i] = 0xa
356 return len(dAtA) - i, nil
357 }
358
359 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
360 offset -= sovGenerated(v)
361 base := offset
362 for v >= 1<<7 {
363 dAtA[offset] = uint8(v&0x7f | 0x80)
364 v >>= 7
365 offset++
366 }
367 dAtA[offset] = uint8(v)
368 return base
369 }
370 func (m *CloudPrivateIPConfig) Size() (n int) {
371 if m == nil {
372 return 0
373 }
374 var l int
375 _ = l
376 l = m.ObjectMeta.Size()
377 n += 1 + l + sovGenerated(uint64(l))
378 l = m.Spec.Size()
379 n += 1 + l + sovGenerated(uint64(l))
380 l = m.Status.Size()
381 n += 1 + l + sovGenerated(uint64(l))
382 return n
383 }
384
385 func (m *CloudPrivateIPConfigList) Size() (n int) {
386 if m == nil {
387 return 0
388 }
389 var l int
390 _ = l
391 l = m.ListMeta.Size()
392 n += 1 + l + sovGenerated(uint64(l))
393 if len(m.Items) > 0 {
394 for _, e := range m.Items {
395 l = e.Size()
396 n += 1 + l + sovGenerated(uint64(l))
397 }
398 }
399 return n
400 }
401
402 func (m *CloudPrivateIPConfigSpec) Size() (n int) {
403 if m == nil {
404 return 0
405 }
406 var l int
407 _ = l
408 l = len(m.Node)
409 n += 1 + l + sovGenerated(uint64(l))
410 return n
411 }
412
413 func (m *CloudPrivateIPConfigStatus) Size() (n int) {
414 if m == nil {
415 return 0
416 }
417 var l int
418 _ = l
419 l = len(m.Node)
420 n += 1 + l + sovGenerated(uint64(l))
421 if len(m.Conditions) > 0 {
422 for _, e := range m.Conditions {
423 l = e.Size()
424 n += 1 + l + sovGenerated(uint64(l))
425 }
426 }
427 return n
428 }
429
430 func sovGenerated(x uint64) (n int) {
431 return (math_bits.Len64(x|1) + 6) / 7
432 }
433 func sozGenerated(x uint64) (n int) {
434 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
435 }
436 func (this *CloudPrivateIPConfig) String() string {
437 if this == nil {
438 return "nil"
439 }
440 s := strings.Join([]string{`&CloudPrivateIPConfig{`,
441 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
442 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CloudPrivateIPConfigSpec", "CloudPrivateIPConfigSpec", 1), `&`, ``, 1) + `,`,
443 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "CloudPrivateIPConfigStatus", "CloudPrivateIPConfigStatus", 1), `&`, ``, 1) + `,`,
444 `}`,
445 }, "")
446 return s
447 }
448 func (this *CloudPrivateIPConfigList) String() string {
449 if this == nil {
450 return "nil"
451 }
452 repeatedStringForItems := "[]CloudPrivateIPConfig{"
453 for _, f := range this.Items {
454 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CloudPrivateIPConfig", "CloudPrivateIPConfig", 1), `&`, ``, 1) + ","
455 }
456 repeatedStringForItems += "}"
457 s := strings.Join([]string{`&CloudPrivateIPConfigList{`,
458 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
459 `Items:` + repeatedStringForItems + `,`,
460 `}`,
461 }, "")
462 return s
463 }
464 func (this *CloudPrivateIPConfigSpec) String() string {
465 if this == nil {
466 return "nil"
467 }
468 s := strings.Join([]string{`&CloudPrivateIPConfigSpec{`,
469 `Node:` + fmt.Sprintf("%v", this.Node) + `,`,
470 `}`,
471 }, "")
472 return s
473 }
474 func (this *CloudPrivateIPConfigStatus) String() string {
475 if this == nil {
476 return "nil"
477 }
478 repeatedStringForConditions := "[]Condition{"
479 for _, f := range this.Conditions {
480 repeatedStringForConditions += fmt.Sprintf("%v", f) + ","
481 }
482 repeatedStringForConditions += "}"
483 s := strings.Join([]string{`&CloudPrivateIPConfigStatus{`,
484 `Node:` + fmt.Sprintf("%v", this.Node) + `,`,
485 `Conditions:` + repeatedStringForConditions + `,`,
486 `}`,
487 }, "")
488 return s
489 }
490 func valueToStringGenerated(v interface{}) string {
491 rv := reflect.ValueOf(v)
492 if rv.IsNil() {
493 return "nil"
494 }
495 pv := reflect.Indirect(rv).Interface()
496 return fmt.Sprintf("*%v", pv)
497 }
498 func (m *CloudPrivateIPConfig) Unmarshal(dAtA []byte) error {
499 l := len(dAtA)
500 iNdEx := 0
501 for iNdEx < l {
502 preIndex := iNdEx
503 var wire uint64
504 for shift := uint(0); ; shift += 7 {
505 if shift >= 64 {
506 return ErrIntOverflowGenerated
507 }
508 if iNdEx >= l {
509 return io.ErrUnexpectedEOF
510 }
511 b := dAtA[iNdEx]
512 iNdEx++
513 wire |= uint64(b&0x7F) << shift
514 if b < 0x80 {
515 break
516 }
517 }
518 fieldNum := int32(wire >> 3)
519 wireType := int(wire & 0x7)
520 if wireType == 4 {
521 return fmt.Errorf("proto: CloudPrivateIPConfig: wiretype end group for non-group")
522 }
523 if fieldNum <= 0 {
524 return fmt.Errorf("proto: CloudPrivateIPConfig: illegal tag %d (wire type %d)", fieldNum, wire)
525 }
526 switch fieldNum {
527 case 1:
528 if wireType != 2 {
529 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
530 }
531 var msglen int
532 for shift := uint(0); ; shift += 7 {
533 if shift >= 64 {
534 return ErrIntOverflowGenerated
535 }
536 if iNdEx >= l {
537 return io.ErrUnexpectedEOF
538 }
539 b := dAtA[iNdEx]
540 iNdEx++
541 msglen |= int(b&0x7F) << shift
542 if b < 0x80 {
543 break
544 }
545 }
546 if msglen < 0 {
547 return ErrInvalidLengthGenerated
548 }
549 postIndex := iNdEx + msglen
550 if postIndex < 0 {
551 return ErrInvalidLengthGenerated
552 }
553 if postIndex > l {
554 return io.ErrUnexpectedEOF
555 }
556 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
557 return err
558 }
559 iNdEx = postIndex
560 case 2:
561 if wireType != 2 {
562 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
563 }
564 var msglen int
565 for shift := uint(0); ; shift += 7 {
566 if shift >= 64 {
567 return ErrIntOverflowGenerated
568 }
569 if iNdEx >= l {
570 return io.ErrUnexpectedEOF
571 }
572 b := dAtA[iNdEx]
573 iNdEx++
574 msglen |= int(b&0x7F) << shift
575 if b < 0x80 {
576 break
577 }
578 }
579 if msglen < 0 {
580 return ErrInvalidLengthGenerated
581 }
582 postIndex := iNdEx + msglen
583 if postIndex < 0 {
584 return ErrInvalidLengthGenerated
585 }
586 if postIndex > l {
587 return io.ErrUnexpectedEOF
588 }
589 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
590 return err
591 }
592 iNdEx = postIndex
593 case 3:
594 if wireType != 2 {
595 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
596 }
597 var msglen int
598 for shift := uint(0); ; shift += 7 {
599 if shift >= 64 {
600 return ErrIntOverflowGenerated
601 }
602 if iNdEx >= l {
603 return io.ErrUnexpectedEOF
604 }
605 b := dAtA[iNdEx]
606 iNdEx++
607 msglen |= int(b&0x7F) << shift
608 if b < 0x80 {
609 break
610 }
611 }
612 if msglen < 0 {
613 return ErrInvalidLengthGenerated
614 }
615 postIndex := iNdEx + msglen
616 if postIndex < 0 {
617 return ErrInvalidLengthGenerated
618 }
619 if postIndex > l {
620 return io.ErrUnexpectedEOF
621 }
622 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
623 return err
624 }
625 iNdEx = postIndex
626 default:
627 iNdEx = preIndex
628 skippy, err := skipGenerated(dAtA[iNdEx:])
629 if err != nil {
630 return err
631 }
632 if (skippy < 0) || (iNdEx+skippy) < 0 {
633 return ErrInvalidLengthGenerated
634 }
635 if (iNdEx + skippy) > l {
636 return io.ErrUnexpectedEOF
637 }
638 iNdEx += skippy
639 }
640 }
641
642 if iNdEx > l {
643 return io.ErrUnexpectedEOF
644 }
645 return nil
646 }
647 func (m *CloudPrivateIPConfigList) Unmarshal(dAtA []byte) error {
648 l := len(dAtA)
649 iNdEx := 0
650 for iNdEx < l {
651 preIndex := iNdEx
652 var wire uint64
653 for shift := uint(0); ; shift += 7 {
654 if shift >= 64 {
655 return ErrIntOverflowGenerated
656 }
657 if iNdEx >= l {
658 return io.ErrUnexpectedEOF
659 }
660 b := dAtA[iNdEx]
661 iNdEx++
662 wire |= uint64(b&0x7F) << shift
663 if b < 0x80 {
664 break
665 }
666 }
667 fieldNum := int32(wire >> 3)
668 wireType := int(wire & 0x7)
669 if wireType == 4 {
670 return fmt.Errorf("proto: CloudPrivateIPConfigList: wiretype end group for non-group")
671 }
672 if fieldNum <= 0 {
673 return fmt.Errorf("proto: CloudPrivateIPConfigList: illegal tag %d (wire type %d)", fieldNum, wire)
674 }
675 switch fieldNum {
676 case 1:
677 if wireType != 2 {
678 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
679 }
680 var msglen int
681 for shift := uint(0); ; shift += 7 {
682 if shift >= 64 {
683 return ErrIntOverflowGenerated
684 }
685 if iNdEx >= l {
686 return io.ErrUnexpectedEOF
687 }
688 b := dAtA[iNdEx]
689 iNdEx++
690 msglen |= int(b&0x7F) << shift
691 if b < 0x80 {
692 break
693 }
694 }
695 if msglen < 0 {
696 return ErrInvalidLengthGenerated
697 }
698 postIndex := iNdEx + msglen
699 if postIndex < 0 {
700 return ErrInvalidLengthGenerated
701 }
702 if postIndex > l {
703 return io.ErrUnexpectedEOF
704 }
705 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
706 return err
707 }
708 iNdEx = postIndex
709 case 2:
710 if wireType != 2 {
711 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
712 }
713 var msglen int
714 for shift := uint(0); ; shift += 7 {
715 if shift >= 64 {
716 return ErrIntOverflowGenerated
717 }
718 if iNdEx >= l {
719 return io.ErrUnexpectedEOF
720 }
721 b := dAtA[iNdEx]
722 iNdEx++
723 msglen |= int(b&0x7F) << shift
724 if b < 0x80 {
725 break
726 }
727 }
728 if msglen < 0 {
729 return ErrInvalidLengthGenerated
730 }
731 postIndex := iNdEx + msglen
732 if postIndex < 0 {
733 return ErrInvalidLengthGenerated
734 }
735 if postIndex > l {
736 return io.ErrUnexpectedEOF
737 }
738 m.Items = append(m.Items, CloudPrivateIPConfig{})
739 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
740 return err
741 }
742 iNdEx = postIndex
743 default:
744 iNdEx = preIndex
745 skippy, err := skipGenerated(dAtA[iNdEx:])
746 if err != nil {
747 return err
748 }
749 if (skippy < 0) || (iNdEx+skippy) < 0 {
750 return ErrInvalidLengthGenerated
751 }
752 if (iNdEx + skippy) > l {
753 return io.ErrUnexpectedEOF
754 }
755 iNdEx += skippy
756 }
757 }
758
759 if iNdEx > l {
760 return io.ErrUnexpectedEOF
761 }
762 return nil
763 }
764 func (m *CloudPrivateIPConfigSpec) Unmarshal(dAtA []byte) error {
765 l := len(dAtA)
766 iNdEx := 0
767 for iNdEx < l {
768 preIndex := iNdEx
769 var wire uint64
770 for shift := uint(0); ; shift += 7 {
771 if shift >= 64 {
772 return ErrIntOverflowGenerated
773 }
774 if iNdEx >= l {
775 return io.ErrUnexpectedEOF
776 }
777 b := dAtA[iNdEx]
778 iNdEx++
779 wire |= uint64(b&0x7F) << shift
780 if b < 0x80 {
781 break
782 }
783 }
784 fieldNum := int32(wire >> 3)
785 wireType := int(wire & 0x7)
786 if wireType == 4 {
787 return fmt.Errorf("proto: CloudPrivateIPConfigSpec: wiretype end group for non-group")
788 }
789 if fieldNum <= 0 {
790 return fmt.Errorf("proto: CloudPrivateIPConfigSpec: illegal tag %d (wire type %d)", fieldNum, wire)
791 }
792 switch fieldNum {
793 case 1:
794 if wireType != 2 {
795 return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
796 }
797 var stringLen uint64
798 for shift := uint(0); ; shift += 7 {
799 if shift >= 64 {
800 return ErrIntOverflowGenerated
801 }
802 if iNdEx >= l {
803 return io.ErrUnexpectedEOF
804 }
805 b := dAtA[iNdEx]
806 iNdEx++
807 stringLen |= uint64(b&0x7F) << shift
808 if b < 0x80 {
809 break
810 }
811 }
812 intStringLen := int(stringLen)
813 if intStringLen < 0 {
814 return ErrInvalidLengthGenerated
815 }
816 postIndex := iNdEx + intStringLen
817 if postIndex < 0 {
818 return ErrInvalidLengthGenerated
819 }
820 if postIndex > l {
821 return io.ErrUnexpectedEOF
822 }
823 m.Node = string(dAtA[iNdEx:postIndex])
824 iNdEx = postIndex
825 default:
826 iNdEx = preIndex
827 skippy, err := skipGenerated(dAtA[iNdEx:])
828 if err != nil {
829 return err
830 }
831 if (skippy < 0) || (iNdEx+skippy) < 0 {
832 return ErrInvalidLengthGenerated
833 }
834 if (iNdEx + skippy) > l {
835 return io.ErrUnexpectedEOF
836 }
837 iNdEx += skippy
838 }
839 }
840
841 if iNdEx > l {
842 return io.ErrUnexpectedEOF
843 }
844 return nil
845 }
846 func (m *CloudPrivateIPConfigStatus) Unmarshal(dAtA []byte) error {
847 l := len(dAtA)
848 iNdEx := 0
849 for iNdEx < l {
850 preIndex := iNdEx
851 var wire uint64
852 for shift := uint(0); ; shift += 7 {
853 if shift >= 64 {
854 return ErrIntOverflowGenerated
855 }
856 if iNdEx >= l {
857 return io.ErrUnexpectedEOF
858 }
859 b := dAtA[iNdEx]
860 iNdEx++
861 wire |= uint64(b&0x7F) << shift
862 if b < 0x80 {
863 break
864 }
865 }
866 fieldNum := int32(wire >> 3)
867 wireType := int(wire & 0x7)
868 if wireType == 4 {
869 return fmt.Errorf("proto: CloudPrivateIPConfigStatus: wiretype end group for non-group")
870 }
871 if fieldNum <= 0 {
872 return fmt.Errorf("proto: CloudPrivateIPConfigStatus: illegal tag %d (wire type %d)", fieldNum, wire)
873 }
874 switch fieldNum {
875 case 1:
876 if wireType != 2 {
877 return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
878 }
879 var stringLen uint64
880 for shift := uint(0); ; shift += 7 {
881 if shift >= 64 {
882 return ErrIntOverflowGenerated
883 }
884 if iNdEx >= l {
885 return io.ErrUnexpectedEOF
886 }
887 b := dAtA[iNdEx]
888 iNdEx++
889 stringLen |= uint64(b&0x7F) << shift
890 if b < 0x80 {
891 break
892 }
893 }
894 intStringLen := int(stringLen)
895 if intStringLen < 0 {
896 return ErrInvalidLengthGenerated
897 }
898 postIndex := iNdEx + intStringLen
899 if postIndex < 0 {
900 return ErrInvalidLengthGenerated
901 }
902 if postIndex > l {
903 return io.ErrUnexpectedEOF
904 }
905 m.Node = string(dAtA[iNdEx:postIndex])
906 iNdEx = postIndex
907 case 2:
908 if wireType != 2 {
909 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
910 }
911 var msglen int
912 for shift := uint(0); ; shift += 7 {
913 if shift >= 64 {
914 return ErrIntOverflowGenerated
915 }
916 if iNdEx >= l {
917 return io.ErrUnexpectedEOF
918 }
919 b := dAtA[iNdEx]
920 iNdEx++
921 msglen |= int(b&0x7F) << shift
922 if b < 0x80 {
923 break
924 }
925 }
926 if msglen < 0 {
927 return ErrInvalidLengthGenerated
928 }
929 postIndex := iNdEx + msglen
930 if postIndex < 0 {
931 return ErrInvalidLengthGenerated
932 }
933 if postIndex > l {
934 return io.ErrUnexpectedEOF
935 }
936 m.Conditions = append(m.Conditions, v1.Condition{})
937 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
938 return err
939 }
940 iNdEx = postIndex
941 default:
942 iNdEx = preIndex
943 skippy, err := skipGenerated(dAtA[iNdEx:])
944 if err != nil {
945 return err
946 }
947 if (skippy < 0) || (iNdEx+skippy) < 0 {
948 return ErrInvalidLengthGenerated
949 }
950 if (iNdEx + skippy) > l {
951 return io.ErrUnexpectedEOF
952 }
953 iNdEx += skippy
954 }
955 }
956
957 if iNdEx > l {
958 return io.ErrUnexpectedEOF
959 }
960 return nil
961 }
962 func skipGenerated(dAtA []byte) (n int, err error) {
963 l := len(dAtA)
964 iNdEx := 0
965 depth := 0
966 for iNdEx < l {
967 var wire uint64
968 for shift := uint(0); ; shift += 7 {
969 if shift >= 64 {
970 return 0, ErrIntOverflowGenerated
971 }
972 if iNdEx >= l {
973 return 0, io.ErrUnexpectedEOF
974 }
975 b := dAtA[iNdEx]
976 iNdEx++
977 wire |= (uint64(b) & 0x7F) << shift
978 if b < 0x80 {
979 break
980 }
981 }
982 wireType := int(wire & 0x7)
983 switch wireType {
984 case 0:
985 for shift := uint(0); ; shift += 7 {
986 if shift >= 64 {
987 return 0, ErrIntOverflowGenerated
988 }
989 if iNdEx >= l {
990 return 0, io.ErrUnexpectedEOF
991 }
992 iNdEx++
993 if dAtA[iNdEx-1] < 0x80 {
994 break
995 }
996 }
997 case 1:
998 iNdEx += 8
999 case 2:
1000 var length int
1001 for shift := uint(0); ; shift += 7 {
1002 if shift >= 64 {
1003 return 0, ErrIntOverflowGenerated
1004 }
1005 if iNdEx >= l {
1006 return 0, io.ErrUnexpectedEOF
1007 }
1008 b := dAtA[iNdEx]
1009 iNdEx++
1010 length |= (int(b) & 0x7F) << shift
1011 if b < 0x80 {
1012 break
1013 }
1014 }
1015 if length < 0 {
1016 return 0, ErrInvalidLengthGenerated
1017 }
1018 iNdEx += length
1019 case 3:
1020 depth++
1021 case 4:
1022 if depth == 0 {
1023 return 0, ErrUnexpectedEndOfGroupGenerated
1024 }
1025 depth--
1026 case 5:
1027 iNdEx += 4
1028 default:
1029 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1030 }
1031 if iNdEx < 0 {
1032 return 0, ErrInvalidLengthGenerated
1033 }
1034 if depth == 0 {
1035 return iNdEx, nil
1036 }
1037 }
1038 return 0, io.ErrUnexpectedEOF
1039 }
1040
1041 var (
1042 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1043 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
1044 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
1045 )
1046
View as plain text