k8s.io/apiserver@v0.31.1/pkg/apis/example2/v1/generated.pb.go (about) 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 )