cmd/bpa-operator/vendor/k8s.io/api/settings/v1alpha1/generated.pb.go

   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/kubernetes/vendor/k8s.io/api/settings/v1alpha1/generated.proto
  19
  20 /*
  21         Package v1alpha1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/settings/v1alpha1/generated.proto
  25
  26         It has these top-level messages:
  27                 PodPreset
  28                 PodPresetList
  29                 PodPresetSpec
  30 */
  31 package v1alpha1
  32
  33 import proto "github.com/gogo/protobuf/proto"
  34 import fmt "fmt"
  35 import math "math"
  36
  37 import k8s_io_api_core_v1 "k8s.io/api/core/v1"
  38
  39 import strings "strings"
  40 import reflect "reflect"
  41
  42 import io "io"
  43
  44 // Reference imports to suppress errors if they are not otherwise used.
  45 var _ = proto.Marshal
  46 var _ = fmt.Errorf
  47 var _ = math.Inf
  48
  49 // This is a compile-time assertion to ensure that this generated file
  50 // is compatible with the proto package it is being compiled against.
  51 // A compilation error at this line likely means your copy of the
  52 // proto package needs to be updated.
  53 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  54
  55 func (m *PodPreset) Reset()                    { *m = PodPreset{} }
  56 func (*PodPreset) ProtoMessage()               {}
  57 func (*PodPreset) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  58
  59 func (m *PodPresetList) Reset()                    { *m = PodPresetList{} }
  60 func (*PodPresetList) ProtoMessage()               {}
  61 func (*PodPresetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  62
  63 func (m *PodPresetSpec) Reset()                    { *m = PodPresetSpec{} }
  64 func (*PodPresetSpec) ProtoMessage()               {}
  65 func (*PodPresetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  66
  67 func init() {
  68         proto.RegisterType((*PodPreset)(nil), "k8s.io.api.settings.v1alpha1.PodPreset")
  69         proto.RegisterType((*PodPresetList)(nil), "k8s.io.api.settings.v1alpha1.PodPresetList")
  70         proto.RegisterType((*PodPresetSpec)(nil), "k8s.io.api.settings.v1alpha1.PodPresetSpec")
  71 }
  72 func (m *PodPreset) Marshal() (dAtA []byte, err error) {
  73         size := m.Size()
  74         dAtA = make([]byte, size)
  75         n, err := m.MarshalTo(dAtA)
  76         if err != nil {
  77                 return nil, err
  78         }
  79         return dAtA[:n], nil
  80 }
  81
  82 func (m *PodPreset) MarshalTo(dAtA []byte) (int, error) {
  83         var i int
  84         _ = i
  85         var l int
  86         _ = l
  87         dAtA[i] = 0xa
  88         i++
  89         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
  90         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
  91         if err != nil {
  92                 return 0, err
  93         }
  94         i += n1
  95         dAtA[i] = 0x12
  96         i++
  97         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
  98         n2, err := m.Spec.MarshalTo(dAtA[i:])
  99         if err != nil {
 100                 return 0, err
 101         }
 102         i += n2
 103         return i, nil
 104 }
 105
 106 func (m *PodPresetList) Marshal() (dAtA []byte, err error) {
 107         size := m.Size()
 108         dAtA = make([]byte, size)
 109         n, err := m.MarshalTo(dAtA)
 110         if err != nil {
 111                 return nil, err
 112         }
 113         return dAtA[:n], nil
 114 }
 115
 116 func (m *PodPresetList) MarshalTo(dAtA []byte) (int, error) {
 117         var i int
 118         _ = i
 119         var l int
 120         _ = l
 121         dAtA[i] = 0xa
 122         i++
 123         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 124         n3, err := m.ListMeta.MarshalTo(dAtA[i:])
 125         if err != nil {
 126                 return 0, err
 127         }
 128         i += n3
 129         if len(m.Items) > 0 {
 130                 for _, msg := range m.Items {
 131                         dAtA[i] = 0x12
 132                         i++
 133                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 134                         n, err := msg.MarshalTo(dAtA[i:])
 135                         if err != nil {
 136                                 return 0, err
 137                         }
 138                         i += n
 139                 }
 140         }
 141         return i, nil
 142 }
 143
 144 func (m *PodPresetSpec) Marshal() (dAtA []byte, err error) {
 145         size := m.Size()
 146         dAtA = make([]byte, size)
 147         n, err := m.MarshalTo(dAtA)
 148         if err != nil {
 149                 return nil, err
 150         }
 151         return dAtA[:n], nil
 152 }
 153
 154 func (m *PodPresetSpec) MarshalTo(dAtA []byte) (int, error) {
 155         var i int
 156         _ = i
 157         var l int
 158         _ = l
 159         dAtA[i] = 0xa
 160         i++
 161         i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 162         n4, err := m.Selector.MarshalTo(dAtA[i:])
 163         if err != nil {
 164                 return 0, err
 165         }
 166         i += n4
 167         if len(m.Env) > 0 {
 168                 for _, msg := range m.Env {
 169                         dAtA[i] = 0x12
 170                         i++
 171                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 172                         n, err := msg.MarshalTo(dAtA[i:])
 173                         if err != nil {
 174                                 return 0, err
 175                         }
 176                         i += n
 177                 }
 178         }
 179         if len(m.EnvFrom) > 0 {
 180                 for _, msg := range m.EnvFrom {
 181                         dAtA[i] = 0x1a
 182                         i++
 183                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 184                         n, err := msg.MarshalTo(dAtA[i:])
 185                         if err != nil {
 186                                 return 0, err
 187                         }
 188                         i += n
 189                 }
 190         }
 191         if len(m.Volumes) > 0 {
 192                 for _, msg := range m.Volumes {
 193                         dAtA[i] = 0x22
 194                         i++
 195                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 196                         n, err := msg.MarshalTo(dAtA[i:])
 197                         if err != nil {
 198                                 return 0, err
 199                         }
 200                         i += n
 201                 }
 202         }
 203         if len(m.VolumeMounts) > 0 {
 204                 for _, msg := range m.VolumeMounts {
 205                         dAtA[i] = 0x2a
 206                         i++
 207                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 208                         n, err := msg.MarshalTo(dAtA[i:])
 209                         if err != nil {
 210                                 return 0, err
 211                         }
 212                         i += n
 213                 }
 214         }
 215         return i, nil
 216 }
 217
 218 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 219         for v >= 1<<7 {
 220                 dAtA[offset] = uint8(v&0x7f | 0x80)
 221                 v >>= 7
 222                 offset++
 223         }
 224         dAtA[offset] = uint8(v)
 225         return offset + 1
 226 }
 227 func (m *PodPreset) Size() (n int) {
 228         var l int
 229         _ = l
 230         l = m.ObjectMeta.Size()
 231         n += 1 + l + sovGenerated(uint64(l))
 232         l = m.Spec.Size()
 233         n += 1 + l + sovGenerated(uint64(l))
 234         return n
 235 }
 236
 237 func (m *PodPresetList) Size() (n int) {
 238         var l int
 239         _ = l
 240         l = m.ListMeta.Size()
 241         n += 1 + l + sovGenerated(uint64(l))
 242         if len(m.Items) > 0 {
 243                 for _, e := range m.Items {
 244                         l = e.Size()
 245                         n += 1 + l + sovGenerated(uint64(l))
 246                 }
 247         }
 248         return n
 249 }
 250
 251 func (m *PodPresetSpec) Size() (n int) {
 252         var l int
 253         _ = l
 254         l = m.Selector.Size()
 255         n += 1 + l + sovGenerated(uint64(l))
 256         if len(m.Env) > 0 {
 257                 for _, e := range m.Env {
 258                         l = e.Size()
 259                         n += 1 + l + sovGenerated(uint64(l))
 260                 }
 261         }
 262         if len(m.EnvFrom) > 0 {
 263                 for _, e := range m.EnvFrom {
 264                         l = e.Size()
 265                         n += 1 + l + sovGenerated(uint64(l))
 266                 }
 267         }
 268         if len(m.Volumes) > 0 {
 269                 for _, e := range m.Volumes {
 270                         l = e.Size()
 271                         n += 1 + l + sovGenerated(uint64(l))
 272                 }
 273         }
 274         if len(m.VolumeMounts) > 0 {
 275                 for _, e := range m.VolumeMounts {
 276                         l = e.Size()
 277                         n += 1 + l + sovGenerated(uint64(l))
 278                 }
 279         }
 280         return n
 281 }
 282
 283 func sovGenerated(x uint64) (n int) {
 284         for {
 285                 n++
 286                 x >>= 7
 287                 if x == 0 {
 288                         break
 289                 }
 290         }
 291         return n
 292 }
 293 func sozGenerated(x uint64) (n int) {
 294         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 295 }
 296 func (this *PodPreset) String() string {
 297         if this == nil {
 298                 return "nil"
 299         }
 300         s := strings.Join([]string{`&PodPreset{`,
 301                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 302                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodPresetSpec", "PodPresetSpec", 1), `&`, ``, 1) + `,`,
 303                 `}`,
 304         }, "")
 305         return s
 306 }
 307 func (this *PodPresetList) String() string {
 308         if this == nil {
 309                 return "nil"
 310         }
 311         s := strings.Join([]string{`&PodPresetList{`,
 312                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 313                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodPreset", "PodPreset", 1), `&`, ``, 1) + `,`,
 314                 `}`,
 315         }, "")
 316         return s
 317 }
 318 func (this *PodPresetSpec) String() string {
 319         if this == nil {
 320                 return "nil"
 321         }
 322         s := strings.Join([]string{`&PodPresetSpec{`,
 323                 `Selector:` + strings.Replace(strings.Replace(this.Selector.String(), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1), `&`, ``, 1) + `,`,
 324                 `Env:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Env), "EnvVar", "k8s_io_api_core_v1.EnvVar", 1), `&`, ``, 1) + `,`,
 325                 `EnvFrom:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.EnvFrom), "EnvFromSource", "k8s_io_api_core_v1.EnvFromSource", 1), `&`, ``, 1) + `,`,
 326                 `Volumes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Volumes), "Volume", "k8s_io_api_core_v1.Volume", 1), `&`, ``, 1) + `,`,
 327                 `VolumeMounts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.VolumeMounts), "VolumeMount", "k8s_io_api_core_v1.VolumeMount", 1), `&`, ``, 1) + `,`,
 328                 `}`,
 329         }, "")
 330         return s
 331 }
 332 func valueToStringGenerated(v interface{}) string {
 333         rv := reflect.ValueOf(v)
 334         if rv.IsNil() {
 335                 return "nil"
 336         }
 337         pv := reflect.Indirect(rv).Interface()
 338         return fmt.Sprintf("*%v", pv)
 339 }
 340 func (m *PodPreset) Unmarshal(dAtA []byte) error {
 341         l := len(dAtA)
 342         iNdEx := 0
 343         for iNdEx < l {
 344                 preIndex := iNdEx
 345                 var wire uint64
 346                 for shift := uint(0); ; shift += 7 {
 347                         if shift >= 64 {
 348                                 return ErrIntOverflowGenerated
 349                         }
 350                         if iNdEx >= l {
 351                                 return io.ErrUnexpectedEOF
 352                         }
 353                         b := dAtA[iNdEx]
 354                         iNdEx++
 355                         wire |= (uint64(b) & 0x7F) << shift
 356                         if b < 0x80 {
 357                                 break
 358                         }
 359                 }
 360                 fieldNum := int32(wire >> 3)
 361                 wireType := int(wire & 0x7)
 362                 if wireType == 4 {
 363                         return fmt.Errorf("proto: PodPreset: wiretype end group for non-group")
 364                 }
 365                 if fieldNum <= 0 {
 366                         return fmt.Errorf("proto: PodPreset: illegal tag %d (wire type %d)", fieldNum, wire)
 367                 }
 368                 switch fieldNum {
 369                 case 1:
 370                         if wireType != 2 {
 371                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 372                         }
 373                         var msglen int
 374                         for shift := uint(0); ; shift += 7 {
 375                                 if shift >= 64 {
 376                                         return ErrIntOverflowGenerated
 377                                 }
 378                                 if iNdEx >= l {
 379                                         return io.ErrUnexpectedEOF
 380                                 }
 381                                 b := dAtA[iNdEx]
 382                                 iNdEx++
 383                                 msglen |= (int(b) & 0x7F) << shift
 384                                 if b < 0x80 {
 385                                         break
 386                                 }
 387                         }
 388                         if msglen < 0 {
 389                                 return ErrInvalidLengthGenerated
 390                         }
 391                         postIndex := iNdEx + msglen
 392                         if postIndex > l {
 393                                 return io.ErrUnexpectedEOF
 394                         }
 395                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 396                                 return err
 397                         }
 398                         iNdEx = postIndex
 399                 case 2:
 400                         if wireType != 2 {
 401                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", 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 > l {
 423                                 return io.ErrUnexpectedEOF
 424                         }
 425                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 426                                 return err
 427                         }
 428                         iNdEx = postIndex
 429                 default:
 430                         iNdEx = preIndex
 431                         skippy, err := skipGenerated(dAtA[iNdEx:])
 432                         if err != nil {
 433                                 return err
 434                         }
 435                         if skippy < 0 {
 436                                 return ErrInvalidLengthGenerated
 437                         }
 438                         if (iNdEx + skippy) > l {
 439                                 return io.ErrUnexpectedEOF
 440                         }
 441                         iNdEx += skippy
 442                 }
 443         }
 444
 445         if iNdEx > l {
 446                 return io.ErrUnexpectedEOF
 447         }
 448         return nil
 449 }
 450 func (m *PodPresetList) Unmarshal(dAtA []byte) error {
 451         l := len(dAtA)
 452         iNdEx := 0
 453         for iNdEx < l {
 454                 preIndex := iNdEx
 455                 var wire uint64
 456                 for shift := uint(0); ; shift += 7 {
 457                         if shift >= 64 {
 458                                 return ErrIntOverflowGenerated
 459                         }
 460                         if iNdEx >= l {
 461                                 return io.ErrUnexpectedEOF
 462                         }
 463                         b := dAtA[iNdEx]
 464                         iNdEx++
 465                         wire |= (uint64(b) & 0x7F) << shift
 466                         if b < 0x80 {
 467                                 break
 468                         }
 469                 }
 470                 fieldNum := int32(wire >> 3)
 471                 wireType := int(wire & 0x7)
 472                 if wireType == 4 {
 473                         return fmt.Errorf("proto: PodPresetList: wiretype end group for non-group")
 474                 }
 475                 if fieldNum <= 0 {
 476                         return fmt.Errorf("proto: PodPresetList: illegal tag %d (wire type %d)", fieldNum, wire)
 477                 }
 478                 switch fieldNum {
 479                 case 1:
 480                         if wireType != 2 {
 481                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 482                         }
 483                         var msglen int
 484                         for shift := uint(0); ; shift += 7 {
 485                                 if shift >= 64 {
 486                                         return ErrIntOverflowGenerated
 487                                 }
 488                                 if iNdEx >= l {
 489                                         return io.ErrUnexpectedEOF
 490                                 }
 491                                 b := dAtA[iNdEx]
 492                                 iNdEx++
 493                                 msglen |= (int(b) & 0x7F) << shift
 494                                 if b < 0x80 {
 495                                         break
 496                                 }
 497                         }
 498                         if msglen < 0 {
 499                                 return ErrInvalidLengthGenerated
 500                         }
 501                         postIndex := iNdEx + msglen
 502                         if postIndex > l {
 503                                 return io.ErrUnexpectedEOF
 504                         }
 505                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 506                                 return err
 507                         }
 508                         iNdEx = postIndex
 509                 case 2:
 510                         if wireType != 2 {
 511                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 512                         }
 513                         var msglen int
 514                         for shift := uint(0); ; shift += 7 {
 515                                 if shift >= 64 {
 516                                         return ErrIntOverflowGenerated
 517                                 }
 518                                 if iNdEx >= l {
 519                                         return io.ErrUnexpectedEOF
 520                                 }
 521                                 b := dAtA[iNdEx]
 522                                 iNdEx++
 523                                 msglen |= (int(b) & 0x7F) << shift
 524                                 if b < 0x80 {
 525                                         break
 526                                 }
 527                         }
 528                         if msglen < 0 {
 529                                 return ErrInvalidLengthGenerated
 530                         }
 531                         postIndex := iNdEx + msglen
 532                         if postIndex > l {
 533                                 return io.ErrUnexpectedEOF
 534                         }
 535                         m.Items = append(m.Items, PodPreset{})
 536                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 537                                 return err
 538                         }
 539                         iNdEx = postIndex
 540                 default:
 541                         iNdEx = preIndex
 542                         skippy, err := skipGenerated(dAtA[iNdEx:])
 543                         if err != nil {
 544                                 return err
 545                         }
 546                         if skippy < 0 {
 547                                 return ErrInvalidLengthGenerated
 548                         }
 549                         if (iNdEx + skippy) > l {
 550                                 return io.ErrUnexpectedEOF
 551                         }
 552                         iNdEx += skippy
 553                 }
 554         }
 555
 556         if iNdEx > l {
 557                 return io.ErrUnexpectedEOF
 558         }
 559         return nil
 560 }
 561 func (m *PodPresetSpec) Unmarshal(dAtA []byte) error {
 562         l := len(dAtA)
 563         iNdEx := 0
 564         for iNdEx < l {
 565                 preIndex := iNdEx
 566                 var wire uint64
 567                 for shift := uint(0); ; shift += 7 {
 568                         if shift >= 64 {
 569                                 return ErrIntOverflowGenerated
 570                         }
 571                         if iNdEx >= l {
 572                                 return io.ErrUnexpectedEOF
 573                         }
 574                         b := dAtA[iNdEx]
 575                         iNdEx++
 576                         wire |= (uint64(b) & 0x7F) << shift
 577                         if b < 0x80 {
 578                                 break
 579                         }
 580                 }
 581                 fieldNum := int32(wire >> 3)
 582                 wireType := int(wire & 0x7)
 583                 if wireType == 4 {
 584                         return fmt.Errorf("proto: PodPresetSpec: wiretype end group for non-group")
 585                 }
 586                 if fieldNum <= 0 {
 587                         return fmt.Errorf("proto: PodPresetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 588                 }
 589                 switch fieldNum {
 590                 case 1:
 591                         if wireType != 2 {
 592                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
 593                         }
 594                         var msglen int
 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                                 msglen |= (int(b) & 0x7F) << shift
 605                                 if b < 0x80 {
 606                                         break
 607                                 }
 608                         }
 609                         if msglen < 0 {
 610                                 return ErrInvalidLengthGenerated
 611                         }
 612                         postIndex := iNdEx + msglen
 613                         if postIndex > l {
 614                                 return io.ErrUnexpectedEOF
 615                         }
 616                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 617                                 return err
 618                         }
 619                         iNdEx = postIndex
 620                 case 2:
 621                         if wireType != 2 {
 622                                 return fmt.Errorf("proto: wrong wireType = %d for field Env", wireType)
 623                         }
 624                         var msglen int
 625                         for shift := uint(0); ; shift += 7 {
 626                                 if shift >= 64 {
 627                                         return ErrIntOverflowGenerated
 628                                 }
 629                                 if iNdEx >= l {
 630                                         return io.ErrUnexpectedEOF
 631                                 }
 632                                 b := dAtA[iNdEx]
 633                                 iNdEx++
 634                                 msglen |= (int(b) & 0x7F) << shift
 635                                 if b < 0x80 {
 636                                         break
 637                                 }
 638                         }
 639                         if msglen < 0 {
 640                                 return ErrInvalidLengthGenerated
 641                         }
 642                         postIndex := iNdEx + msglen
 643                         if postIndex > l {
 644                                 return io.ErrUnexpectedEOF
 645                         }
 646                         m.Env = append(m.Env, k8s_io_api_core_v1.EnvVar{})
 647                         if err := m.Env[len(m.Env)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 648                                 return err
 649                         }
 650                         iNdEx = postIndex
 651                 case 3:
 652                         if wireType != 2 {
 653                                 return fmt.Errorf("proto: wrong wireType = %d for field EnvFrom", wireType)
 654                         }
 655                         var msglen int
 656                         for shift := uint(0); ; shift += 7 {
 657                                 if shift >= 64 {
 658                                         return ErrIntOverflowGenerated
 659                                 }
 660                                 if iNdEx >= l {
 661                                         return io.ErrUnexpectedEOF
 662                                 }
 663                                 b := dAtA[iNdEx]
 664                                 iNdEx++
 665                                 msglen |= (int(b) & 0x7F) << shift
 666                                 if b < 0x80 {
 667                                         break
 668                                 }
 669                         }
 670                         if msglen < 0 {
 671                                 return ErrInvalidLengthGenerated
 672                         }
 673                         postIndex := iNdEx + msglen
 674                         if postIndex > l {
 675                                 return io.ErrUnexpectedEOF
 676                         }
 677                         m.EnvFrom = append(m.EnvFrom, k8s_io_api_core_v1.EnvFromSource{})
 678                         if err := m.EnvFrom[len(m.EnvFrom)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 679                                 return err
 680                         }
 681                         iNdEx = postIndex
 682                 case 4:
 683                         if wireType != 2 {
 684                                 return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
 685                         }
 686                         var msglen int
 687                         for shift := uint(0); ; shift += 7 {
 688                                 if shift >= 64 {
 689                                         return ErrIntOverflowGenerated
 690                                 }
 691                                 if iNdEx >= l {
 692                                         return io.ErrUnexpectedEOF
 693                                 }
 694                                 b := dAtA[iNdEx]
 695                                 iNdEx++
 696                                 msglen |= (int(b) & 0x7F) << shift
 697                                 if b < 0x80 {
 698                                         break
 699                                 }
 700                         }
 701                         if msglen < 0 {
 702                                 return ErrInvalidLengthGenerated
 703                         }
 704                         postIndex := iNdEx + msglen
 705                         if postIndex > l {
 706                                 return io.ErrUnexpectedEOF
 707                         }
 708                         m.Volumes = append(m.Volumes, k8s_io_api_core_v1.Volume{})
 709                         if err := m.Volumes[len(m.Volumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 710                                 return err
 711                         }
 712                         iNdEx = postIndex
 713                 case 5:
 714                         if wireType != 2 {
 715                                 return fmt.Errorf("proto: wrong wireType = %d for field VolumeMounts", wireType)
 716                         }
 717                         var msglen int
 718                         for shift := uint(0); ; shift += 7 {
 719                                 if shift >= 64 {
 720                                         return ErrIntOverflowGenerated
 721                                 }
 722                                 if iNdEx >= l {
 723                                         return io.ErrUnexpectedEOF
 724                                 }
 725                                 b := dAtA[iNdEx]
 726                                 iNdEx++
 727                                 msglen |= (int(b) & 0x7F) << shift
 728                                 if b < 0x80 {
 729                                         break
 730                                 }
 731                         }
 732                         if msglen < 0 {
 733                                 return ErrInvalidLengthGenerated
 734                         }
 735                         postIndex := iNdEx + msglen
 736                         if postIndex > l {
 737                                 return io.ErrUnexpectedEOF
 738                         }
 739                         m.VolumeMounts = append(m.VolumeMounts, k8s_io_api_core_v1.VolumeMount{})
 740                         if err := m.VolumeMounts[len(m.VolumeMounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 741                                 return err
 742                         }
 743                         iNdEx = postIndex
 744                 default:
 745                         iNdEx = preIndex
 746                         skippy, err := skipGenerated(dAtA[iNdEx:])
 747                         if err != nil {
 748                                 return err
 749                         }
 750                         if skippy < 0 {
 751                                 return ErrInvalidLengthGenerated
 752                         }
 753                         if (iNdEx + skippy) > l {
 754                                 return io.ErrUnexpectedEOF
 755                         }
 756                         iNdEx += skippy
 757                 }
 758         }
 759
 760         if iNdEx > l {
 761                 return io.ErrUnexpectedEOF
 762         }
 763         return nil
 764 }
 765 func skipGenerated(dAtA []byte) (n int, err error) {
 766         l := len(dAtA)
 767         iNdEx := 0
 768         for iNdEx < l {
 769                 var wire uint64
 770                 for shift := uint(0); ; shift += 7 {
 771                         if shift >= 64 {
 772                                 return 0, ErrIntOverflowGenerated
 773                         }
 774                         if iNdEx >= l {
 775                                 return 0, io.ErrUnexpectedEOF
 776                         }
 777                         b := dAtA[iNdEx]
 778                         iNdEx++
 779                         wire |= (uint64(b) & 0x7F) << shift
 780                         if b < 0x80 {
 781                                 break
 782                         }
 783                 }
 784                 wireType := int(wire & 0x7)
 785                 switch wireType {
 786                 case 0:
 787                         for shift := uint(0); ; shift += 7 {
 788                                 if shift >= 64 {
 789                                         return 0, ErrIntOverflowGenerated
 790                                 }
 791                                 if iNdEx >= l {
 792                                         return 0, io.ErrUnexpectedEOF
 793                                 }
 794                                 iNdEx++
 795                                 if dAtA[iNdEx-1] < 0x80 {
 796                                         break
 797                                 }
 798                         }
 799                         return iNdEx, nil
 800                 case 1:
 801                         iNdEx += 8
 802                         return iNdEx, nil
 803                 case 2:
 804                         var length int
 805                         for shift := uint(0); ; shift += 7 {
 806                                 if shift >= 64 {
 807                                         return 0, ErrIntOverflowGenerated
 808                                 }
 809                                 if iNdEx >= l {
 810                                         return 0, io.ErrUnexpectedEOF
 811                                 }
 812                                 b := dAtA[iNdEx]
 813                                 iNdEx++
 814                                 length |= (int(b) & 0x7F) << shift
 815                                 if b < 0x80 {
 816                                         break
 817                                 }
 818                         }
 819                         iNdEx += length
 820                         if length < 0 {
 821                                 return 0, ErrInvalidLengthGenerated
 822                         }
 823                         return iNdEx, nil
 824                 case 3:
 825                         for {
 826                                 var innerWire uint64
 827                                 var start int = iNdEx
 828                                 for shift := uint(0); ; shift += 7 {
 829                                         if shift >= 64 {
 830                                                 return 0, ErrIntOverflowGenerated
 831                                         }
 832                                         if iNdEx >= l {
 833                                                 return 0, io.ErrUnexpectedEOF
 834                                         }
 835                                         b := dAtA[iNdEx]
 836                                         iNdEx++
 837                                         innerWire |= (uint64(b) & 0x7F) << shift
 838                                         if b < 0x80 {
 839                                                 break
 840                                         }
 841                                 }
 842                                 innerWireType := int(innerWire & 0x7)
 843                                 if innerWireType == 4 {
 844                                         break
 845                                 }
 846                                 next, err := skipGenerated(dAtA[start:])
 847                                 if err != nil {
 848                                         return 0, err
 849                                 }
 850                                 iNdEx = start + next
 851                         }
 852                         return iNdEx, nil
 853                 case 4:
 854                         return iNdEx, nil
 855                 case 5:
 856                         iNdEx += 4
 857                         return iNdEx, nil
 858                 default:
 859                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 860                 }
 861         }
 862         panic("unreachable")
 863 }
 864
 865 var (
 866         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
 867         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
 868 )
 869
 870 func init() {
 871         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/settings/v1alpha1/generated.proto", fileDescriptorGenerated)
 872 }
 873
 874 var fileDescriptorGenerated = []byte{
 875         // 542 bytes of a gzipped FileDescriptorProto
 876         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x8e, 0xd2, 0x40,
 877         0x1c, 0xc6, 0xe9, 0xb2, 0x04, 0x1c, 0xd8, 0x68, 0x1a, 0x0f, 0x0d, 0x31, 0x65, 0xe5, 0xe2, 0x26,
 878         0xc6, 0x19, 0x59, 0x8d, 0xd1, 0x6b, 0x13, 0x4c, 0x4c, 0x20, 0x6e, 0x4a, 0xb2, 0x89, 0xc6, 0x83,
 879         0x43, 0xf9, 0x5b, 0x2a, 0xb4, 0xd3, 0xcc, 0x4c, 0x9b, 0x78, 0xf3, 0x11, 0x7c, 0x01, 0x9f, 0x44,
 880         0x1f, 0x80, 0xe3, 0x1e, 0xf7, 0xb4, 0x91, 0xfa, 0x22, 0x66, 0x86, 0x29, 0xa0, 0x88, 0x72, 0x9b,
 881         0xff, 0x9f, 0xef, 0xfb, 0xcd, 0xf7, 0x31, 0x45, 0xfd, 0xd9, 0x73, 0x81, 0x23, 0x46, 0x66, 0xd9,
 882         0x18, 0x78, 0x02, 0x12, 0x04, 0xc9, 0x21, 0x99, 0x30, 0x4e, 0xcc, 0x0f, 0x34, 0x8d, 0x88, 0x00,
 883         0x29, 0xa3, 0x24, 0x14, 0x24, 0xef, 0xd1, 0x79, 0x3a, 0xa5, 0x3d, 0x12, 0x42, 0x02, 0x9c, 0x4a,
 884         0x98, 0xe0, 0x94, 0x33, 0xc9, 0xec, 0x7b, 0x2b, 0x35, 0xa6, 0x69, 0x84, 0x4b, 0x35, 0x2e, 0xd5,
 885         0xed, 0x47, 0x61, 0x24, 0xa7, 0xd9, 0x18, 0x07, 0x2c, 0x26, 0x21, 0x0b, 0x19, 0xd1, 0xa6, 0x71,
 886         0xf6, 0x41, 0x4f, 0x7a, 0xd0, 0xa7, 0x15, 0xac, 0xdd, 0xdd, 0xba, 0x3a, 0x60, 0x1c, 0x48, 0xbe,
 887         0x73, 0x61, 0xfb, 0xe9, 0x46, 0x13, 0xd3, 0x60, 0x1a, 0x25, 0xc0, 0x3f, 0x91, 0x74, 0x16, 0xaa,
 888         0x85, 0x20, 0x31, 0x48, 0xfa, 0x37, 0x17, 0xd9, 0xe7, 0xe2, 0x59, 0x22, 0xa3, 0x18, 0x76, 0x0c,
 889         0xcf, 0xfe, 0x67, 0x10, 0xc1, 0x14, 0x62, 0xfa, 0xa7, 0xaf, 0xfb, 0xdd, 0x42, 0xb7, 0x2e, 0xd8,
 890         0xe4, 0x82, 0x83, 0x00, 0x69, 0xbf, 0x47, 0x0d, 0x95, 0x68, 0x42, 0x25, 0x75, 0xac, 0x53, 0xeb,
 891         0xac, 0x79, 0xfe, 0x18, 0x6f, 0xfe, 0xb0, 0x35, 0x18, 0xa7, 0xb3, 0x50, 0x2d, 0x04, 0x56, 0x6a,
 892         0x9c, 0xf7, 0xf0, 0xeb, 0xf1, 0x47, 0x08, 0xe4, 0x10, 0x24, 0xf5, 0xec, 0xc5, 0x4d, 0xa7, 0x52,
 893         0xdc, 0x74, 0xd0, 0x66, 0xe7, 0xaf, 0xa9, 0xf6, 0x10, 0x1d, 0x8b, 0x14, 0x02, 0xe7, 0x48, 0xd3,
 894         0x1f, 0xe2, 0x7f, 0x3d, 0x07, 0x5e, 0x07, 0x1b, 0xa5, 0x10, 0x78, 0x2d, 0x03, 0x3e, 0x56, 0x93,
 895         0xaf, 0x31, 0xdd, 0x6f, 0x16, 0x3a, 0x59, 0xab, 0x06, 0x91, 0x90, 0xf6, 0xbb, 0x9d, 0x0a, 0xf8,
 896         0xb0, 0x0a, 0xca, 0xad, 0x0b, 0xdc, 0x31, 0xf7, 0x34, 0xca, 0xcd, 0x56, 0xfc, 0x01, 0xaa, 0x45,
 897         0x12, 0x62, 0xe1, 0x1c, 0x9d, 0x56, 0xcf, 0x9a, 0xe7, 0x0f, 0x0e, 0xcc, 0xef, 0x9d, 0x18, 0x66,
 898         0xed, 0x95, 0x72, 0xfb, 0x2b, 0x48, 0xf7, 0x6b, 0x75, 0x2b, 0xbd, 0x6a, 0x65, 0x53, 0xd4, 0x10,
 899         0x30, 0x87, 0x40, 0x32, 0x6e, 0xd2, 0x3f, 0x39, 0x30, 0x3d, 0x1d, 0xc3, 0x7c, 0x64, 0xac, 0x9b,
 900         0x0a, 0xe5, 0xc6, 0x5f, 0x63, 0xed, 0x17, 0xa8, 0x0a, 0x49, 0x6e, 0x0a, 0xb4, 0xb7, 0x0b, 0xa8,
 901         0x4f, 0x58, 0xb1, 0xfa, 0x49, 0x7e, 0x49, 0xb9, 0xd7, 0x34, 0x90, 0x6a, 0x3f, 0xc9, 0x7d, 0xe5,
 902         0xb1, 0x07, 0xa8, 0x0e, 0x49, 0xfe, 0x92, 0xb3, 0xd8, 0xa9, 0x6a, 0xfb, 0xfd, 0x3d, 0x76, 0x25,
 903         0x19, 0xb1, 0x8c, 0x07, 0xe0, 0xdd, 0x36, 0x94, 0xba, 0x59, 0xfb, 0x25, 0xc2, 0xee, 0xa3, 0x7a,
 904         0xce, 0xe6, 0x59, 0x0c, 0xc2, 0x39, 0xde, 0x1f, 0xe6, 0x52, 0x4b, 0x36, 0x98, 0xd5, 0x2c, 0xfc,
 905         0xd2, 0x6b, 0xbf, 0x41, 0xad, 0xd5, 0x71, 0xc8, 0xb2, 0x44, 0x0a, 0xa7, 0xa6, 0x59, 0x9d, 0xfd,
 906         0x2c, 0xad, 0xf3, 0xee, 0x1a, 0x60, 0x6b, 0x6b, 0x29, 0xfc, 0xdf, 0x50, 0x1e, 0x5e, 0x2c, 0xdd,
 907         0xca, 0xd5, 0xd2, 0xad, 0x5c, 0x2f, 0xdd, 0xca, 0xe7, 0xc2, 0xb5, 0x16, 0x85, 0x6b, 0x5d, 0x15,
 908         0xae, 0x75, 0x5d, 0xb8, 0xd6, 0x8f, 0xc2, 0xb5, 0xbe, 0xfc, 0x74, 0x2b, 0x6f, 0x1b, 0xe5, 0x7b,
 909         0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x46, 0x15, 0xf2, 0x97, 0xa4, 0x04, 0x00, 0x00,
 910 }