Debian Codegraph @

pkg/apis/example2/v1/generated.pb.go

raw
1 /*
2 Copyright The Kubernetes Authors.
3
4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15 */
16
17 // Code generated by protoc-gen-gogo. DO NOT EDIT.
18 // source: k8s.io/apiserver/pkg/apis/example2/v1/generated.proto
19
20 package v1
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28
29 math "math"
30 math_bits "math/bits"
31 reflect "reflect"
32 strings "strings"
33 )
34
35 // Reference imports to suppress errors if they are not otherwise used.
36 var _ = proto.Marshal
37 var _ = fmt.Errorf
38 var _ = math.Inf
39
40 // This is a compile-time assertion to ensure that this generated file
41 // is compatible with the proto package it is being compiled against.
42 // A compilation error at this line likely means your copy of the
43 // proto package needs to be updated.
44 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
45
46 func (m *ReplicaSet) Reset() { *m = ReplicaSet{} }
47 func (*ReplicaSet) ProtoMessage() {}
48 func (*ReplicaSet) Descriptor() ([]byte, []int) {
49 return fileDescriptor_c0d8f6d73eb5bf83, []int{0}
50 }
51 func (m *ReplicaSet) XXX_Unmarshal(b []byte) error {
52 return m.Unmarshal(b)
53 }
54 func (m *ReplicaSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
55 b = b[:cap(b)]
56 n, err := m.MarshalToSizedBuffer(b)
57 if err != nil {
58 return nil, err
59 }
60 return b[:n], nil
61 }
62 func (m *ReplicaSet) XXX_Merge(src proto.Message) {
63 xxx_messageInfo_ReplicaSet.Merge(m, src)
64 }
65 func (m *ReplicaSet) XXX_Size() int {
66 return m.Size()
67 }
68 func (m *ReplicaSet) XXX_DiscardUnknown() {
69 xxx_messageInfo_ReplicaSet.DiscardUnknown(m)
70 }
71
72 var xxx_messageInfo_ReplicaSet proto.InternalMessageInfo
73
74 func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} }
75 func (*ReplicaSetSpec) ProtoMessage() {}
76 func (*ReplicaSetSpec) Descriptor() ([]byte, []int) {
77 return fileDescriptor_c0d8f6d73eb5bf83, []int{1}
78 }
79 func (m *ReplicaSetSpec) XXX_Unmarshal(b []byte) error {
80 return m.Unmarshal(b)
81 }
82 func (m *ReplicaSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
83 b = b[:cap(b)]
84 n, err := m.MarshalToSizedBuffer(b)
85 if err != nil {
86 return nil, err
87 }
88 return b[:n], nil
89 }
90 func (m *ReplicaSetSpec) XXX_Merge(src proto.Message) {
91 xxx_messageInfo_ReplicaSetSpec.Merge(m, src)
92 }
93 func (m *ReplicaSetSpec) XXX_Size() int {
94 return m.Size()
95 }
96 func (m *ReplicaSetSpec) XXX_DiscardUnknown() {
97 xxx_messageInfo_ReplicaSetSpec.DiscardUnknown(m)
98 }
99
100 var xxx_messageInfo_ReplicaSetSpec proto.InternalMessageInfo
101
102 func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} }
103 func (*ReplicaSetStatus) ProtoMessage() {}
104 func (*ReplicaSetStatus) Descriptor() ([]byte, []int) {
105 return fileDescriptor_c0d8f6d73eb5bf83, []int{2}
106 }
107 func (m *ReplicaSetStatus) XXX_Unmarshal(b []byte) error {
108 return m.Unmarshal(b)
109 }
110 func (m *ReplicaSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
111 b = b[:cap(b)]
112 n, err := m.MarshalToSizedBuffer(b)
113 if err != nil {
114 return nil, err
115 }
116 return b[:n], nil
117 }
118 func (m *ReplicaSetStatus) XXX_Merge(src proto.Message) {
119 xxx_messageInfo_ReplicaSetStatus.Merge(m, src)
120 }
121 func (m *ReplicaSetStatus) XXX_Size() int {
122 return m.Size()
123 }
124 func (m *ReplicaSetStatus) XXX_DiscardUnknown() {
125 xxx_messageInfo_ReplicaSetStatus.DiscardUnknown(m)
126 }
127
128 var xxx_messageInfo_ReplicaSetStatus proto.InternalMessageInfo
129
130 func init() {
131 proto.RegisterType((*ReplicaSet)(nil), "k8s.io.apiserver.pkg.apis.example2.v1.ReplicaSet")
132 proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.apiserver.pkg.apis.example2.v1.ReplicaSetSpec")
133 proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.apiserver.pkg.apis.example2.v1.ReplicaSetStatus")
134 }
135
136 func init() {
137 proto.RegisterFile("k8s.io/apiserver/pkg/apis/example2/v1/generated.proto", fileDescriptor_c0d8f6d73eb5bf83)
138 }
139
140 var fileDescriptor_c0d8f6d73eb5bf83 = []byte{
141 // 388 bytes of a gzipped FileDescriptorProto
142 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xc1, 0x6a, 0xe2, 0x40,
143 0x18, 0xc7, 0x13, 0xd7, 0x15, 0x99, 0x15, 0x91, 0x9c, 0xc4, 0xc3, 0xb8, 0x08, 0x82, 0x87, 0xdd,
144 0x99, 0x55, 0xd6, 0xdd, 0xd2, 0x53, 0xc9, 0xb5, 0x94, 0x42, 0x3c, 0x14, 0x7a, 0x69, 0xc7, 0xf8,
145 0x35, 0xa6, 0x1a, 0x33, 0x64, 0x26, 0xa1, 0xbd, 0xf5, 0x11, 0xfa, 0x18, 0x7d, 0x14, 0x8f, 0x1e,
146 0x3d, 0x49, 0x4d, 0x5f, 0xa4, 0x38, 0x49, 0x13, 0xaa, 0x96, 0xda, 0x5b, 0xfe, 0x93, 0xf9, 0xfd,
147 0xbe, 0x3f, 0x1f, 0x83, 0xfa, 0x93, 0x23, 0x41, 0x5c, 0x9f, 0x32, 0xee, 0x0a, 0x08, 0x22, 0x08,
148 0x28, 0x9f, 0x38, 0x2a, 0x51, 0xb8, 0x63, 0x1e, 0x9f, 0x42, 0x8f, 0x46, 0x5d, 0xea, 0xc0, 0x0c,
149 0x02, 0x26, 0x61, 0x44, 0x78, 0xe0, 0x4b, 0xdf, 0x68, 0x27, 0x18, 0xc9, 0x30, 0xc2, 0x27, 0x8e,
150 0x4a, 0xe4, 0x0d, 0x23, 0x51, 0xb7, 0xf1, 0xdb, 0x71, 0xe5, 0x38, 0x1c, 0x12, 0xdb, 0xf7, 0xa8,
151 0xe3, 0x3b, 0x3e, 0x55, 0xf4, 0x30, 0xbc, 0x51, 0x49, 0x05, 0xf5, 0x95, 0x58, 0x1b, 0x7f, 0xf3,
152 0x32, 0x1e, 0xb3, 0xc7, 0xee, 0x0c, 0x82, 0xfb, 0xbc, 0x8f, 0x07, 0x92, 0xed, 0xe9, 0xd2, 0xa0,
153 0x1f, 0x51, 0x41, 0x38, 0x93, 0xae, 0x07, 0x3b, 0xc0, 0xbf, 0xcf, 0x00, 0x61, 0x8f, 0xc1, 0x63,
154 0xdb, 0x5c, 0xeb, 0xa9, 0x80, 0x90, 0x05, 0x7c, 0xea, 0xda, 0x6c, 0x00, 0xd2, 0xb8, 0x46, 0xe5,
155 0x4d, 0xa5, 0x11, 0x93, 0xac, 0xae, 0xff, 0xd4, 0x3b, 0x3f, 0x7a, 0x7f, 0x48, 0xbe, 0x96, 0xcc,
156 0x9c, 0x6f, 0x66, 0x73, 0x9b, 0x44, 0x5d, 0x72, 0x3e, 0xbc, 0x05, 0x5b, 0x9e, 0x81, 0x64, 0xa6,
157 0x31, 0x5f, 0x35, 0xb5, 0x78, 0xd5, 0x44, 0xf9, 0x99, 0x95, 0x59, 0x8d, 0x0b, 0x54, 0x14, 0x1c,
158 0xec, 0x7a, 0x41, 0xd9, 0xfb, 0xe4, 0xa0, 0xa5, 0x93, 0xbc, 0xe2, 0x80, 0x83, 0x6d, 0x56, 0xd2,
159 0x11, 0xc5, 0x4d, 0xb2, 0x94, 0xd0, 0xb8, 0x42, 0x25, 0x21, 0x99, 0x0c, 0x45, 0xfd, 0x9b, 0x52,
160 0xff, 0xff, 0xba, 0x5a, 0xe1, 0x66, 0x35, 0x95, 0x97, 0x92, 0x6c, 0xa5, 0xda, 0xd6, 0x31, 0xaa,
161 0xbe, 0xaf, 0x61, 0x74, 0x50, 0x39, 0x48, 0x4e, 0x84, 0xda, 0xd6, 0x77, 0xb3, 0x12, 0xaf, 0x9a,
162 0xe5, 0xf4, 0x96, 0xb0, 0xb2, 0xbf, 0xad, 0x13, 0x54, 0xdb, 0x9e, 0x63, 0xfc, 0xda, 0xa1, 0x6b,
163 0xe9, 0xe4, 0x3d, 0x06, 0xf3, 0x74, 0xbe, 0xc6, 0xda, 0x62, 0x8d, 0xb5, 0xe5, 0x1a, 0x6b, 0x0f,
164 0x31, 0xd6, 0xe7, 0x31, 0xd6, 0x17, 0x31, 0xd6, 0x97, 0x31, 0xd6, 0x9f, 0x63, 0xac, 0x3f, 0xbe,
165 0x60, 0xed, 0xb2, 0x7d, 0xd0, 0xd3, 0x7f, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xf4, 0xd7, 0x7c, 0xa3,
166 0x22, 0x03, 0x00, 0x00,
167 }
168
169 func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
170 size := m.Size()
171 dAtA = make([]byte, size)
172 n, err := m.MarshalToSizedBuffer(dAtA[:size])
173 if err != nil {
174 return nil, err
175 }
176 return dAtA[:n], nil
177 }
178
179 func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
180 size := m.Size()
181 return m.MarshalToSizedBuffer(dAtA[:size])
182 }
183
184 func (m *ReplicaSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
185 i := len(dAtA)
186 _ = i
187 var l int
188 _ = l
189 {
190 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
191 if err != nil {
192 return 0, err
193 }
194 i -= size
195 i = encodeVarintGenerated(dAtA, i, uint64(size))
196 }
197 i--
198 dAtA[i] = 0x1a
199 {
200 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
201 if err != nil {
202 return 0, err
203 }
204 i -= size
205 i = encodeVarintGenerated(dAtA, i, uint64(size))
206 }
207 i--
208 dAtA[i] = 0x12
209 {
210 size, err := m.ObjectMeta.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] = 0xa
219 return len(dAtA) - i, nil
220 }
221
222 func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
223 size := m.Size()
224 dAtA = make([]byte, size)
225 n, err := m.MarshalToSizedBuffer(dAtA[:size])
226 if err != nil {
227 return nil, err
228 }
229 return dAtA[:n], nil
230 }
231
232 func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
233 size := m.Size()
234 return m.MarshalToSizedBuffer(dAtA[:size])
235 }
236
237 func (m *ReplicaSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
238 i := len(dAtA)
239 _ = i
240 var l int
241 _ = l
242 if m.Replicas != nil {
243 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
244 i--
245 dAtA[i] = 0x8
246 }
247 return len(dAtA) - i, nil
248 }
249
250 func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
251 size := m.Size()
252 dAtA = make([]byte, size)
253 n, err := m.MarshalToSizedBuffer(dAtA[:size])
254 if err != nil {
255 return nil, err
256 }
257 return dAtA[:n], nil
258 }
259
260 func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
261 size := m.Size()
262 return m.MarshalToSizedBuffer(dAtA[:size])
263 }
264
265 func (m *ReplicaSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
266 i := len(dAtA)
267 _ = i
268 var l int
269 _ = l
270 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
271 i--
272 dAtA[i] = 0x8
273 return len(dAtA) - i, nil
274 }
275
276 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
277 offset -= sovGenerated(v)
278 base := offset
279 for v >= 1<<7 {
280 dAtA[offset] = uint8(v&0x7f | 0x80)
281 v >>= 7
282 offset++
283 }
284 dAtA[offset] = uint8(v)
285 return base
286 }
287 func (m *ReplicaSet) Size() (n int) {
288 if m == nil {
289 return 0
290 }
291 var l int
292 _ = l
293 l = m.ObjectMeta.Size()
294 n += 1 + l + sovGenerated(uint64(l))
295 l = m.Spec.Size()
296 n += 1 + l + sovGenerated(uint64(l))
297 l = m.Status.Size()
298 n += 1 + l + sovGenerated(uint64(l))
299 return n
300 }
301
302 func (m *ReplicaSetSpec) Size() (n int) {
303 if m == nil {
304 return 0
305 }
306 var l int
307 _ = l
308 if m.Replicas != nil {
309 n += 1 + sovGenerated(uint64(*m.Replicas))
310 }
311 return n
312 }
313
314 func (m *ReplicaSetStatus) Size() (n int) {
315 if m == nil {
316 return 0
317 }
318 var l int
319 _ = l
320 n += 1 + sovGenerated(uint64(m.Replicas))
321 return n
322 }
323
324 func sovGenerated(x uint64) (n int) {
325 return (math_bits.Len64(x|1) + 6) / 7
326 }
327 func sozGenerated(x uint64) (n int) {
328 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
329 }
330 func (this *ReplicaSet) String() string {
331 if this == nil {
332 return "nil"
333 }
334 s := strings.Join([]string{`&ReplicaSet{`,
335 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
336 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
337 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
338 `}`,
339 }, "")
340 return s
341 }
342 func (this *ReplicaSetSpec) String() string {
343 if this == nil {
344 return "nil"
345 }
346 s := strings.Join([]string{`&ReplicaSetSpec{`,
347 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
348 `}`,
349 }, "")
350 return s
351 }
352 func (this *ReplicaSetStatus) String() string {
353 if this == nil {
354 return "nil"
355 }
356 s := strings.Join([]string{`&ReplicaSetStatus{`,
357 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
358 `}`,
359 }, "")
360 return s
361 }
362 func valueToStringGenerated(v interface{}) string {
363 rv := reflect.ValueOf(v)
364 if rv.IsNil() {
365 return "nil"
366 }
367 pv := reflect.Indirect(rv).Interface()
368 return fmt.Sprintf("*%v", pv)
369 }
370 func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
371 l := len(dAtA)
372 iNdEx := 0
373 for iNdEx < l {
374 preIndex := iNdEx
375 var wire uint64
376 for shift := uint(0); ; shift += 7 {
377 if shift >= 64 {
378 return ErrIntOverflowGenerated
379 }
380 if iNdEx >= l {
381 return io.ErrUnexpectedEOF
382 }
383 b := dAtA[iNdEx]
384 iNdEx++
385 wire |= uint64(b&0x7F) << shift
386 if b < 0x80 {
387 break
388 }
389 }
390 fieldNum := int32(wire >> 3)
391 wireType := int(wire & 0x7)
392 if wireType == 4 {
393 return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
394 }
395 if fieldNum <= 0 {
396 return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
397 }
398 switch fieldNum {
399 case 1:
400 if wireType != 2 {
401 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
402 }
403 var msglen int
404 for shift := uint(0); ; shift += 7 {
405 if shift >= 64 {
406 return ErrIntOverflowGenerated
407 }
408 if iNdEx >= l {
409 return io.ErrUnexpectedEOF
410 }
411 b := dAtA[iNdEx]
412 iNdEx++
413 msglen |= int(b&0x7F) << shift
414 if b < 0x80 {
415 break
416 }
417 }
418 if msglen < 0 {
419 return ErrInvalidLengthGenerated
420 }
421 postIndex := iNdEx + msglen
422 if postIndex < 0 {
423 return ErrInvalidLengthGenerated
424 }
425 if postIndex > l {
426 return io.ErrUnexpectedEOF
427 }
428 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
429 return err
430 }
431 iNdEx = postIndex
432 case 2:
433 if wireType != 2 {
434 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
435 }
436 var msglen int
437 for shift := uint(0); ; shift += 7 {
438 if shift >= 64 {
439 return ErrIntOverflowGenerated
440 }
441 if iNdEx >= l {
442 return io.ErrUnexpectedEOF
443 }
444 b := dAtA[iNdEx]
445 iNdEx++
446 msglen |= int(b&0x7F) << shift
447 if b < 0x80 {
448 break
449 }
450 }
451 if msglen < 0 {
452 return ErrInvalidLengthGenerated
453 }
454 postIndex := iNdEx + msglen
455 if postIndex < 0 {
456 return ErrInvalidLengthGenerated
457 }
458 if postIndex > l {
459 return io.ErrUnexpectedEOF
460 }
461 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
462 return err
463 }
464 iNdEx = postIndex
465 case 3:
466 if wireType != 2 {
467 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
468 }
469 var msglen int
470 for shift := uint(0); ; shift += 7 {
471 if shift >= 64 {
472 return ErrIntOverflowGenerated
473 }
474 if iNdEx >= l {
475 return io.ErrUnexpectedEOF
476 }
477 b := dAtA[iNdEx]
478 iNdEx++
479 msglen |= int(b&0x7F) << shift
480 if b < 0x80 {
481 break
482 }
483 }
484 if msglen < 0 {
485 return ErrInvalidLengthGenerated
486 }
487 postIndex := iNdEx + msglen
488 if postIndex < 0 {
489 return ErrInvalidLengthGenerated
490 }
491 if postIndex > l {
492 return io.ErrUnexpectedEOF
493 }
494 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
495 return err
496 }
497 iNdEx = postIndex
498 default:
499 iNdEx = preIndex
500 skippy, err := skipGenerated(dAtA[iNdEx:])
501 if err != nil {
502 return err
503 }
504 if (skippy < 0) || (iNdEx+skippy) < 0 {
505 return ErrInvalidLengthGenerated
506 }
507 if (iNdEx + skippy) > l {
508 return io.ErrUnexpectedEOF
509 }
510 iNdEx += skippy
511 }
512 }
513
514 if iNdEx > l {
515 return io.ErrUnexpectedEOF
516 }
517 return nil
518 }
519 func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
520 l := len(dAtA)
521 iNdEx := 0
522 for iNdEx < l {
523 preIndex := iNdEx
524 var wire uint64
525 for shift := uint(0); ; shift += 7 {
526 if shift >= 64 {
527 return ErrIntOverflowGenerated
528 }
529 if iNdEx >= l {
530 return io.ErrUnexpectedEOF
531 }
532 b := dAtA[iNdEx]
533 iNdEx++
534 wire |= uint64(b&0x7F) << shift
535 if b < 0x80 {
536 break
537 }
538 }
539 fieldNum := int32(wire >> 3)
540 wireType := int(wire & 0x7)
541 if wireType == 4 {
542 return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
543 }
544 if fieldNum <= 0 {
545 return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
546 }
547 switch fieldNum {
548 case 1:
549 if wireType != 0 {
550 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
551 }
552 var v int32
553 for shift := uint(0); ; shift += 7 {
554 if shift >= 64 {
555 return ErrIntOverflowGenerated
556 }
557 if iNdEx >= l {
558 return io.ErrUnexpectedEOF
559 }
560 b := dAtA[iNdEx]
561 iNdEx++
562 v |= int32(b&0x7F) << shift
563 if b < 0x80 {
564 break
565 }
566 }
567 m.Replicas = &v
568 default:
569 iNdEx = preIndex
570 skippy, err := skipGenerated(dAtA[iNdEx:])
571 if err != nil {
572 return err
573 }
574 if (skippy < 0) || (iNdEx+skippy) < 0 {
575 return ErrInvalidLengthGenerated
576 }
577 if (iNdEx + skippy) > l {
578 return io.ErrUnexpectedEOF
579 }
580 iNdEx += skippy
581 }
582 }
583
584 if iNdEx > l {
585 return io.ErrUnexpectedEOF
586 }
587 return nil
588 }
589 func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
590 l := len(dAtA)
591 iNdEx := 0
592 for iNdEx < l {
593 preIndex := iNdEx
594 var wire uint64
595 for shift := uint(0); ; shift += 7 {
596 if shift >= 64 {
597 return ErrIntOverflowGenerated
598 }
599 if iNdEx >= l {
600 return io.ErrUnexpectedEOF
601 }
602 b := dAtA[iNdEx]
603 iNdEx++
604 wire |= uint64(b&0x7F) << shift
605 if b < 0x80 {
606 break
607 }
608 }
609 fieldNum := int32(wire >> 3)
610 wireType := int(wire & 0x7)
611 if wireType == 4 {
612 return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
613 }
614 if fieldNum <= 0 {
615 return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
616 }
617 switch fieldNum {
618 case 1:
619 if wireType != 0 {
620 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
621 }
622 m.Replicas = 0
623 for shift := uint(0); ; shift += 7 {
624 if shift >= 64 {
625 return ErrIntOverflowGenerated
626 }
627 if iNdEx >= l {
628 return io.ErrUnexpectedEOF
629 }
630 b := dAtA[iNdEx]
631 iNdEx++
632 m.Replicas |= int32(b&0x7F) << shift
633 if b < 0x80 {
634 break
635 }
636 }
637 default:
638 iNdEx = preIndex
639 skippy, err := skipGenerated(dAtA[iNdEx:])
640 if err != nil {
641 return err
642 }
643 if (skippy < 0) || (iNdEx+skippy) < 0 {
644 return ErrInvalidLengthGenerated
645 }
646 if (iNdEx + skippy) > l {
647 return io.ErrUnexpectedEOF
648 }
649 iNdEx += skippy
650 }
651 }
652
653 if iNdEx > l {
654 return io.ErrUnexpectedEOF
655 }
656 return nil
657 }
658 func skipGenerated(dAtA []byte) (n int, err error) {
659 l := len(dAtA)
660 iNdEx := 0
661 depth := 0
662 for iNdEx < l {
663 var wire uint64
664 for shift := uint(0); ; shift += 7 {
665 if shift >= 64 {
666 return 0, ErrIntOverflowGenerated
667 }
668 if iNdEx >= l {
669 return 0, io.ErrUnexpectedEOF
670 }
671 b := dAtA[iNdEx]
672 iNdEx++
673 wire |= (uint64(b) & 0x7F) << shift
674 if b < 0x80 {
675 break
676 }
677 }
678 wireType := int(wire & 0x7)
679 switch wireType {
680 case 0:
681 for shift := uint(0); ; shift += 7 {
682 if shift >= 64 {
683 return 0, ErrIntOverflowGenerated
684 }
685 if iNdEx >= l {
686 return 0, io.ErrUnexpectedEOF
687 }
688 iNdEx++
689 if dAtA[iNdEx-1] < 0x80 {
690 break
691 }
692 }
693 case 1:
694 iNdEx += 8
695 case 2:
696 var length int
697 for shift := uint(0); ; shift += 7 {
698 if shift >= 64 {
699 return 0, ErrIntOverflowGenerated
700 }
701 if iNdEx >= l {
702 return 0, io.ErrUnexpectedEOF
703 }
704 b := dAtA[iNdEx]
705 iNdEx++
706 length |= (int(b) & 0x7F) << shift
707 if b < 0x80 {
708 break
709 }
710 }
711 if length < 0 {
712 return 0, ErrInvalidLengthGenerated
713 }
714 iNdEx += length
715 case 3:
716 depth++
717 case 4:
718 if depth == 0 {
719 return 0, ErrUnexpectedEndOfGroupGenerated
720 }
721 depth--
722 case 5:
723 iNdEx += 4
724 default:
725 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
726 }
727 if iNdEx < 0 {
728 return 0, ErrInvalidLengthGenerated
729 }
730 if depth == 0 {
731 return iNdEx, nil
732 }
733 }
734 return 0, io.ErrUnexpectedEOF
735 }
736
737 var (
738 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
739 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
740 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
741 )