cmd/bpa-operator/vendor/k8s.io/api/rbac/v1/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/rbac/v1/generated.proto
  19
  20 /*
  21         Package v1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/rbac/v1/generated.proto
  25
  26         It has these top-level messages:
  27                 AggregationRule
  28                 ClusterRole
  29                 ClusterRoleBinding
  30                 ClusterRoleBindingList
  31                 ClusterRoleList
  32                 PolicyRule
  33                 Role
  34                 RoleBinding
  35                 RoleBindingList
  36                 RoleList
  37                 RoleRef
  38                 Subject
  39 */
  40 package v1
  41
  42 import proto "github.com/gogo/protobuf/proto"
  43 import fmt "fmt"
  44 import math "math"
  45
  46 import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  47
  48 import strings "strings"
  49 import reflect "reflect"
  50
  51 import io "io"
  52
  53 // Reference imports to suppress errors if they are not otherwise used.
  54 var _ = proto.Marshal
  55 var _ = fmt.Errorf
  56 var _ = math.Inf
  57
  58 // This is a compile-time assertion to ensure that this generated file
  59 // is compatible with the proto package it is being compiled against.
  60 // A compilation error at this line likely means your copy of the
  61 // proto package needs to be updated.
  62 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  63
  64 func (m *AggregationRule) Reset()                    { *m = AggregationRule{} }
  65 func (*AggregationRule) ProtoMessage()               {}
  66 func (*AggregationRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  67
  68 func (m *ClusterRole) Reset()                    { *m = ClusterRole{} }
  69 func (*ClusterRole) ProtoMessage()               {}
  70 func (*ClusterRole) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  71
  72 func (m *ClusterRoleBinding) Reset()                    { *m = ClusterRoleBinding{} }
  73 func (*ClusterRoleBinding) ProtoMessage()               {}
  74 func (*ClusterRoleBinding) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  75
  76 func (m *ClusterRoleBindingList) Reset()                    { *m = ClusterRoleBindingList{} }
  77 func (*ClusterRoleBindingList) ProtoMessage()               {}
  78 func (*ClusterRoleBindingList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
  79
  80 func (m *ClusterRoleList) Reset()                    { *m = ClusterRoleList{} }
  81 func (*ClusterRoleList) ProtoMessage()               {}
  82 func (*ClusterRoleList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
  83
  84 func (m *PolicyRule) Reset()                    { *m = PolicyRule{} }
  85 func (*PolicyRule) ProtoMessage()               {}
  86 func (*PolicyRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
  87
  88 func (m *Role) Reset()                    { *m = Role{} }
  89 func (*Role) ProtoMessage()               {}
  90 func (*Role) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
  91
  92 func (m *RoleBinding) Reset()                    { *m = RoleBinding{} }
  93 func (*RoleBinding) ProtoMessage()               {}
  94 func (*RoleBinding) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
  95
  96 func (m *RoleBindingList) Reset()                    { *m = RoleBindingList{} }
  97 func (*RoleBindingList) ProtoMessage()               {}
  98 func (*RoleBindingList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
  99
 100 func (m *RoleList) Reset()                    { *m = RoleList{} }
 101 func (*RoleList) ProtoMessage()               {}
 102 func (*RoleList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
 103
 104 func (m *RoleRef) Reset()                    { *m = RoleRef{} }
 105 func (*RoleRef) ProtoMessage()               {}
 106 func (*RoleRef) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
 107
 108 func (m *Subject) Reset()                    { *m = Subject{} }
 109 func (*Subject) ProtoMessage()               {}
 110 func (*Subject) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
 111
 112 func init() {
 113         proto.RegisterType((*AggregationRule)(nil), "k8s.io.api.rbac.v1.AggregationRule")
 114         proto.RegisterType((*ClusterRole)(nil), "k8s.io.api.rbac.v1.ClusterRole")
 115         proto.RegisterType((*ClusterRoleBinding)(nil), "k8s.io.api.rbac.v1.ClusterRoleBinding")
 116         proto.RegisterType((*ClusterRoleBindingList)(nil), "k8s.io.api.rbac.v1.ClusterRoleBindingList")
 117         proto.RegisterType((*ClusterRoleList)(nil), "k8s.io.api.rbac.v1.ClusterRoleList")
 118         proto.RegisterType((*PolicyRule)(nil), "k8s.io.api.rbac.v1.PolicyRule")
 119         proto.RegisterType((*Role)(nil), "k8s.io.api.rbac.v1.Role")
 120         proto.RegisterType((*RoleBinding)(nil), "k8s.io.api.rbac.v1.RoleBinding")
 121         proto.RegisterType((*RoleBindingList)(nil), "k8s.io.api.rbac.v1.RoleBindingList")
 122         proto.RegisterType((*RoleList)(nil), "k8s.io.api.rbac.v1.RoleList")
 123         proto.RegisterType((*RoleRef)(nil), "k8s.io.api.rbac.v1.RoleRef")
 124         proto.RegisterType((*Subject)(nil), "k8s.io.api.rbac.v1.Subject")
 125 }
 126 func (m *AggregationRule) Marshal() (dAtA []byte, err error) {
 127         size := m.Size()
 128         dAtA = make([]byte, size)
 129         n, err := m.MarshalTo(dAtA)
 130         if err != nil {
 131                 return nil, err
 132         }
 133         return dAtA[:n], nil
 134 }
 135
 136 func (m *AggregationRule) MarshalTo(dAtA []byte) (int, error) {
 137         var i int
 138         _ = i
 139         var l int
 140         _ = l
 141         if len(m.ClusterRoleSelectors) > 0 {
 142                 for _, msg := range m.ClusterRoleSelectors {
 143                         dAtA[i] = 0xa
 144                         i++
 145                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 146                         n, err := msg.MarshalTo(dAtA[i:])
 147                         if err != nil {
 148                                 return 0, err
 149                         }
 150                         i += n
 151                 }
 152         }
 153         return i, nil
 154 }
 155
 156 func (m *ClusterRole) Marshal() (dAtA []byte, err error) {
 157         size := m.Size()
 158         dAtA = make([]byte, size)
 159         n, err := m.MarshalTo(dAtA)
 160         if err != nil {
 161                 return nil, err
 162         }
 163         return dAtA[:n], nil
 164 }
 165
 166 func (m *ClusterRole) MarshalTo(dAtA []byte) (int, error) {
 167         var i int
 168         _ = i
 169         var l int
 170         _ = l
 171         dAtA[i] = 0xa
 172         i++
 173         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 174         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 175         if err != nil {
 176                 return 0, err
 177         }
 178         i += n1
 179         if len(m.Rules) > 0 {
 180                 for _, msg := range m.Rules {
 181                         dAtA[i] = 0x12
 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 m.AggregationRule != nil {
 192                 dAtA[i] = 0x1a
 193                 i++
 194                 i = encodeVarintGenerated(dAtA, i, uint64(m.AggregationRule.Size()))
 195                 n2, err := m.AggregationRule.MarshalTo(dAtA[i:])
 196                 if err != nil {
 197                         return 0, err
 198                 }
 199                 i += n2
 200         }
 201         return i, nil
 202 }
 203
 204 func (m *ClusterRoleBinding) Marshal() (dAtA []byte, err error) {
 205         size := m.Size()
 206         dAtA = make([]byte, size)
 207         n, err := m.MarshalTo(dAtA)
 208         if err != nil {
 209                 return nil, err
 210         }
 211         return dAtA[:n], nil
 212 }
 213
 214 func (m *ClusterRoleBinding) MarshalTo(dAtA []byte) (int, error) {
 215         var i int
 216         _ = i
 217         var l int
 218         _ = l
 219         dAtA[i] = 0xa
 220         i++
 221         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 222         n3, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 223         if err != nil {
 224                 return 0, err
 225         }
 226         i += n3
 227         if len(m.Subjects) > 0 {
 228                 for _, msg := range m.Subjects {
 229                         dAtA[i] = 0x12
 230                         i++
 231                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 232                         n, err := msg.MarshalTo(dAtA[i:])
 233                         if err != nil {
 234                                 return 0, err
 235                         }
 236                         i += n
 237                 }
 238         }
 239         dAtA[i] = 0x1a
 240         i++
 241         i = encodeVarintGenerated(dAtA, i, uint64(m.RoleRef.Size()))
 242         n4, err := m.RoleRef.MarshalTo(dAtA[i:])
 243         if err != nil {
 244                 return 0, err
 245         }
 246         i += n4
 247         return i, nil
 248 }
 249
 250 func (m *ClusterRoleBindingList) Marshal() (dAtA []byte, err error) {
 251         size := m.Size()
 252         dAtA = make([]byte, size)
 253         n, err := m.MarshalTo(dAtA)
 254         if err != nil {
 255                 return nil, err
 256         }
 257         return dAtA[:n], nil
 258 }
 259
 260 func (m *ClusterRoleBindingList) MarshalTo(dAtA []byte) (int, error) {
 261         var i int
 262         _ = i
 263         var l int
 264         _ = l
 265         dAtA[i] = 0xa
 266         i++
 267         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 268         n5, err := m.ListMeta.MarshalTo(dAtA[i:])
 269         if err != nil {
 270                 return 0, err
 271         }
 272         i += n5
 273         if len(m.Items) > 0 {
 274                 for _, msg := range m.Items {
 275                         dAtA[i] = 0x12
 276                         i++
 277                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 278                         n, err := msg.MarshalTo(dAtA[i:])
 279                         if err != nil {
 280                                 return 0, err
 281                         }
 282                         i += n
 283                 }
 284         }
 285         return i, nil
 286 }
 287
 288 func (m *ClusterRoleList) Marshal() (dAtA []byte, err error) {
 289         size := m.Size()
 290         dAtA = make([]byte, size)
 291         n, err := m.MarshalTo(dAtA)
 292         if err != nil {
 293                 return nil, err
 294         }
 295         return dAtA[:n], nil
 296 }
 297
 298 func (m *ClusterRoleList) MarshalTo(dAtA []byte) (int, error) {
 299         var i int
 300         _ = i
 301         var l int
 302         _ = l
 303         dAtA[i] = 0xa
 304         i++
 305         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 306         n6, err := m.ListMeta.MarshalTo(dAtA[i:])
 307         if err != nil {
 308                 return 0, err
 309         }
 310         i += n6
 311         if len(m.Items) > 0 {
 312                 for _, msg := range m.Items {
 313                         dAtA[i] = 0x12
 314                         i++
 315                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 316                         n, err := msg.MarshalTo(dAtA[i:])
 317                         if err != nil {
 318                                 return 0, err
 319                         }
 320                         i += n
 321                 }
 322         }
 323         return i, nil
 324 }
 325
 326 func (m *PolicyRule) Marshal() (dAtA []byte, err error) {
 327         size := m.Size()
 328         dAtA = make([]byte, size)
 329         n, err := m.MarshalTo(dAtA)
 330         if err != nil {
 331                 return nil, err
 332         }
 333         return dAtA[:n], nil
 334 }
 335
 336 func (m *PolicyRule) MarshalTo(dAtA []byte) (int, error) {
 337         var i int
 338         _ = i
 339         var l int
 340         _ = l
 341         if len(m.Verbs) > 0 {
 342                 for _, s := range m.Verbs {
 343                         dAtA[i] = 0xa
 344                         i++
 345                         l = len(s)
 346                         for l >= 1<<7 {
 347                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 348                                 l >>= 7
 349                                 i++
 350                         }
 351                         dAtA[i] = uint8(l)
 352                         i++
 353                         i += copy(dAtA[i:], s)
 354                 }
 355         }
 356         if len(m.APIGroups) > 0 {
 357                 for _, s := range m.APIGroups {
 358                         dAtA[i] = 0x12
 359                         i++
 360                         l = len(s)
 361                         for l >= 1<<7 {
 362                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 363                                 l >>= 7
 364                                 i++
 365                         }
 366                         dAtA[i] = uint8(l)
 367                         i++
 368                         i += copy(dAtA[i:], s)
 369                 }
 370         }
 371         if len(m.Resources) > 0 {
 372                 for _, s := range m.Resources {
 373                         dAtA[i] = 0x1a
 374                         i++
 375                         l = len(s)
 376                         for l >= 1<<7 {
 377                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 378                                 l >>= 7
 379                                 i++
 380                         }
 381                         dAtA[i] = uint8(l)
 382                         i++
 383                         i += copy(dAtA[i:], s)
 384                 }
 385         }
 386         if len(m.ResourceNames) > 0 {
 387                 for _, s := range m.ResourceNames {
 388                         dAtA[i] = 0x22
 389                         i++
 390                         l = len(s)
 391                         for l >= 1<<7 {
 392                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 393                                 l >>= 7
 394                                 i++
 395                         }
 396                         dAtA[i] = uint8(l)
 397                         i++
 398                         i += copy(dAtA[i:], s)
 399                 }
 400         }
 401         if len(m.NonResourceURLs) > 0 {
 402                 for _, s := range m.NonResourceURLs {
 403                         dAtA[i] = 0x2a
 404                         i++
 405                         l = len(s)
 406                         for l >= 1<<7 {
 407                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 408                                 l >>= 7
 409                                 i++
 410                         }
 411                         dAtA[i] = uint8(l)
 412                         i++
 413                         i += copy(dAtA[i:], s)
 414                 }
 415         }
 416         return i, nil
 417 }
 418
 419 func (m *Role) Marshal() (dAtA []byte, err error) {
 420         size := m.Size()
 421         dAtA = make([]byte, size)
 422         n, err := m.MarshalTo(dAtA)
 423         if err != nil {
 424                 return nil, err
 425         }
 426         return dAtA[:n], nil
 427 }
 428
 429 func (m *Role) MarshalTo(dAtA []byte) (int, error) {
 430         var i int
 431         _ = i
 432         var l int
 433         _ = l
 434         dAtA[i] = 0xa
 435         i++
 436         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 437         n7, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 438         if err != nil {
 439                 return 0, err
 440         }
 441         i += n7
 442         if len(m.Rules) > 0 {
 443                 for _, msg := range m.Rules {
 444                         dAtA[i] = 0x12
 445                         i++
 446                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 447                         n, err := msg.MarshalTo(dAtA[i:])
 448                         if err != nil {
 449                                 return 0, err
 450                         }
 451                         i += n
 452                 }
 453         }
 454         return i, nil
 455 }
 456
 457 func (m *RoleBinding) Marshal() (dAtA []byte, err error) {
 458         size := m.Size()
 459         dAtA = make([]byte, size)
 460         n, err := m.MarshalTo(dAtA)
 461         if err != nil {
 462                 return nil, err
 463         }
 464         return dAtA[:n], nil
 465 }
 466
 467 func (m *RoleBinding) MarshalTo(dAtA []byte) (int, error) {
 468         var i int
 469         _ = i
 470         var l int
 471         _ = l
 472         dAtA[i] = 0xa
 473         i++
 474         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 475         n8, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 476         if err != nil {
 477                 return 0, err
 478         }
 479         i += n8
 480         if len(m.Subjects) > 0 {
 481                 for _, msg := range m.Subjects {
 482                         dAtA[i] = 0x12
 483                         i++
 484                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 485                         n, err := msg.MarshalTo(dAtA[i:])
 486                         if err != nil {
 487                                 return 0, err
 488                         }
 489                         i += n
 490                 }
 491         }
 492         dAtA[i] = 0x1a
 493         i++
 494         i = encodeVarintGenerated(dAtA, i, uint64(m.RoleRef.Size()))
 495         n9, err := m.RoleRef.MarshalTo(dAtA[i:])
 496         if err != nil {
 497                 return 0, err
 498         }
 499         i += n9
 500         return i, nil
 501 }
 502
 503 func (m *RoleBindingList) Marshal() (dAtA []byte, err error) {
 504         size := m.Size()
 505         dAtA = make([]byte, size)
 506         n, err := m.MarshalTo(dAtA)
 507         if err != nil {
 508                 return nil, err
 509         }
 510         return dAtA[:n], nil
 511 }
 512
 513 func (m *RoleBindingList) MarshalTo(dAtA []byte) (int, error) {
 514         var i int
 515         _ = i
 516         var l int
 517         _ = l
 518         dAtA[i] = 0xa
 519         i++
 520         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 521         n10, err := m.ListMeta.MarshalTo(dAtA[i:])
 522         if err != nil {
 523                 return 0, err
 524         }
 525         i += n10
 526         if len(m.Items) > 0 {
 527                 for _, msg := range m.Items {
 528                         dAtA[i] = 0x12
 529                         i++
 530                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 531                         n, err := msg.MarshalTo(dAtA[i:])
 532                         if err != nil {
 533                                 return 0, err
 534                         }
 535                         i += n
 536                 }
 537         }
 538         return i, nil
 539 }
 540
 541 func (m *RoleList) Marshal() (dAtA []byte, err error) {
 542         size := m.Size()
 543         dAtA = make([]byte, size)
 544         n, err := m.MarshalTo(dAtA)
 545         if err != nil {
 546                 return nil, err
 547         }
 548         return dAtA[:n], nil
 549 }
 550
 551 func (m *RoleList) MarshalTo(dAtA []byte) (int, error) {
 552         var i int
 553         _ = i
 554         var l int
 555         _ = l
 556         dAtA[i] = 0xa
 557         i++
 558         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 559         n11, err := m.ListMeta.MarshalTo(dAtA[i:])
 560         if err != nil {
 561                 return 0, err
 562         }
 563         i += n11
 564         if len(m.Items) > 0 {
 565                 for _, msg := range m.Items {
 566                         dAtA[i] = 0x12
 567                         i++
 568                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 569                         n, err := msg.MarshalTo(dAtA[i:])
 570                         if err != nil {
 571                                 return 0, err
 572                         }
 573                         i += n
 574                 }
 575         }
 576         return i, nil
 577 }
 578
 579 func (m *RoleRef) Marshal() (dAtA []byte, err error) {
 580         size := m.Size()
 581         dAtA = make([]byte, size)
 582         n, err := m.MarshalTo(dAtA)
 583         if err != nil {
 584                 return nil, err
 585         }
 586         return dAtA[:n], nil
 587 }
 588
 589 func (m *RoleRef) MarshalTo(dAtA []byte) (int, error) {
 590         var i int
 591         _ = i
 592         var l int
 593         _ = l
 594         dAtA[i] = 0xa
 595         i++
 596         i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIGroup)))
 597         i += copy(dAtA[i:], m.APIGroup)
 598         dAtA[i] = 0x12
 599         i++
 600         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 601         i += copy(dAtA[i:], m.Kind)
 602         dAtA[i] = 0x1a
 603         i++
 604         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 605         i += copy(dAtA[i:], m.Name)
 606         return i, nil
 607 }
 608
 609 func (m *Subject) Marshal() (dAtA []byte, err error) {
 610         size := m.Size()
 611         dAtA = make([]byte, size)
 612         n, err := m.MarshalTo(dAtA)
 613         if err != nil {
 614                 return nil, err
 615         }
 616         return dAtA[:n], nil
 617 }
 618
 619 func (m *Subject) MarshalTo(dAtA []byte) (int, error) {
 620         var i int
 621         _ = i
 622         var l int
 623         _ = l
 624         dAtA[i] = 0xa
 625         i++
 626         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 627         i += copy(dAtA[i:], m.Kind)
 628         dAtA[i] = 0x12
 629         i++
 630         i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIGroup)))
 631         i += copy(dAtA[i:], m.APIGroup)
 632         dAtA[i] = 0x1a
 633         i++
 634         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 635         i += copy(dAtA[i:], m.Name)
 636         dAtA[i] = 0x22
 637         i++
 638         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
 639         i += copy(dAtA[i:], m.Namespace)
 640         return i, nil
 641 }
 642
 643 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 644         for v >= 1<<7 {
 645                 dAtA[offset] = uint8(v&0x7f | 0x80)
 646                 v >>= 7
 647                 offset++
 648         }
 649         dAtA[offset] = uint8(v)
 650         return offset + 1
 651 }
 652 func (m *AggregationRule) Size() (n int) {
 653         var l int
 654         _ = l
 655         if len(m.ClusterRoleSelectors) > 0 {
 656                 for _, e := range m.ClusterRoleSelectors {
 657                         l = e.Size()
 658                         n += 1 + l + sovGenerated(uint64(l))
 659                 }
 660         }
 661         return n
 662 }
 663
 664 func (m *ClusterRole) Size() (n int) {
 665         var l int
 666         _ = l
 667         l = m.ObjectMeta.Size()
 668         n += 1 + l + sovGenerated(uint64(l))
 669         if len(m.Rules) > 0 {
 670                 for _, e := range m.Rules {
 671                         l = e.Size()
 672                         n += 1 + l + sovGenerated(uint64(l))
 673                 }
 674         }
 675         if m.AggregationRule != nil {
 676                 l = m.AggregationRule.Size()
 677                 n += 1 + l + sovGenerated(uint64(l))
 678         }
 679         return n
 680 }
 681
 682 func (m *ClusterRoleBinding) Size() (n int) {
 683         var l int
 684         _ = l
 685         l = m.ObjectMeta.Size()
 686         n += 1 + l + sovGenerated(uint64(l))
 687         if len(m.Subjects) > 0 {
 688                 for _, e := range m.Subjects {
 689                         l = e.Size()
 690                         n += 1 + l + sovGenerated(uint64(l))
 691                 }
 692         }
 693         l = m.RoleRef.Size()
 694         n += 1 + l + sovGenerated(uint64(l))
 695         return n
 696 }
 697
 698 func (m *ClusterRoleBindingList) Size() (n int) {
 699         var l int
 700         _ = l
 701         l = m.ListMeta.Size()
 702         n += 1 + l + sovGenerated(uint64(l))
 703         if len(m.Items) > 0 {
 704                 for _, e := range m.Items {
 705                         l = e.Size()
 706                         n += 1 + l + sovGenerated(uint64(l))
 707                 }
 708         }
 709         return n
 710 }
 711
 712 func (m *ClusterRoleList) Size() (n int) {
 713         var l int
 714         _ = l
 715         l = m.ListMeta.Size()
 716         n += 1 + l + sovGenerated(uint64(l))
 717         if len(m.Items) > 0 {
 718                 for _, e := range m.Items {
 719                         l = e.Size()
 720                         n += 1 + l + sovGenerated(uint64(l))
 721                 }
 722         }
 723         return n
 724 }
 725
 726 func (m *PolicyRule) Size() (n int) {
 727         var l int
 728         _ = l
 729         if len(m.Verbs) > 0 {
 730                 for _, s := range m.Verbs {
 731                         l = len(s)
 732                         n += 1 + l + sovGenerated(uint64(l))
 733                 }
 734         }
 735         if len(m.APIGroups) > 0 {
 736                 for _, s := range m.APIGroups {
 737                         l = len(s)
 738                         n += 1 + l + sovGenerated(uint64(l))
 739                 }
 740         }
 741         if len(m.Resources) > 0 {
 742                 for _, s := range m.Resources {
 743                         l = len(s)
 744                         n += 1 + l + sovGenerated(uint64(l))
 745                 }
 746         }
 747         if len(m.ResourceNames) > 0 {
 748                 for _, s := range m.ResourceNames {
 749                         l = len(s)
 750                         n += 1 + l + sovGenerated(uint64(l))
 751                 }
 752         }
 753         if len(m.NonResourceURLs) > 0 {
 754                 for _, s := range m.NonResourceURLs {
 755                         l = len(s)
 756                         n += 1 + l + sovGenerated(uint64(l))
 757                 }
 758         }
 759         return n
 760 }
 761
 762 func (m *Role) Size() (n int) {
 763         var l int
 764         _ = l
 765         l = m.ObjectMeta.Size()
 766         n += 1 + l + sovGenerated(uint64(l))
 767         if len(m.Rules) > 0 {
 768                 for _, e := range m.Rules {
 769                         l = e.Size()
 770                         n += 1 + l + sovGenerated(uint64(l))
 771                 }
 772         }
 773         return n
 774 }
 775
 776 func (m *RoleBinding) Size() (n int) {
 777         var l int
 778         _ = l
 779         l = m.ObjectMeta.Size()
 780         n += 1 + l + sovGenerated(uint64(l))
 781         if len(m.Subjects) > 0 {
 782                 for _, e := range m.Subjects {
 783                         l = e.Size()
 784                         n += 1 + l + sovGenerated(uint64(l))
 785                 }
 786         }
 787         l = m.RoleRef.Size()
 788         n += 1 + l + sovGenerated(uint64(l))
 789         return n
 790 }
 791
 792 func (m *RoleBindingList) Size() (n int) {
 793         var l int
 794         _ = l
 795         l = m.ListMeta.Size()
 796         n += 1 + l + sovGenerated(uint64(l))
 797         if len(m.Items) > 0 {
 798                 for _, e := range m.Items {
 799                         l = e.Size()
 800                         n += 1 + l + sovGenerated(uint64(l))
 801                 }
 802         }
 803         return n
 804 }
 805
 806 func (m *RoleList) Size() (n int) {
 807         var l int
 808         _ = l
 809         l = m.ListMeta.Size()
 810         n += 1 + l + sovGenerated(uint64(l))
 811         if len(m.Items) > 0 {
 812                 for _, e := range m.Items {
 813                         l = e.Size()
 814                         n += 1 + l + sovGenerated(uint64(l))
 815                 }
 816         }
 817         return n
 818 }
 819
 820 func (m *RoleRef) Size() (n int) {
 821         var l int
 822         _ = l
 823         l = len(m.APIGroup)
 824         n += 1 + l + sovGenerated(uint64(l))
 825         l = len(m.Kind)
 826         n += 1 + l + sovGenerated(uint64(l))
 827         l = len(m.Name)
 828         n += 1 + l + sovGenerated(uint64(l))
 829         return n
 830 }
 831
 832 func (m *Subject) Size() (n int) {
 833         var l int
 834         _ = l
 835         l = len(m.Kind)
 836         n += 1 + l + sovGenerated(uint64(l))
 837         l = len(m.APIGroup)
 838         n += 1 + l + sovGenerated(uint64(l))
 839         l = len(m.Name)
 840         n += 1 + l + sovGenerated(uint64(l))
 841         l = len(m.Namespace)
 842         n += 1 + l + sovGenerated(uint64(l))
 843         return n
 844 }
 845
 846 func sovGenerated(x uint64) (n int) {
 847         for {
 848                 n++
 849                 x >>= 7
 850                 if x == 0 {
 851                         break
 852                 }
 853         }
 854         return n
 855 }
 856 func sozGenerated(x uint64) (n int) {
 857         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 858 }
 859 func (this *AggregationRule) String() string {
 860         if this == nil {
 861                 return "nil"
 862         }
 863         s := strings.Join([]string{`&AggregationRule{`,
 864                 `ClusterRoleSelectors:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ClusterRoleSelectors), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1), `&`, ``, 1) + `,`,
 865                 `}`,
 866         }, "")
 867         return s
 868 }
 869 func (this *ClusterRole) String() string {
 870         if this == nil {
 871                 return "nil"
 872         }
 873         s := strings.Join([]string{`&ClusterRole{`,
 874                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 875                 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "PolicyRule", "PolicyRule", 1), `&`, ``, 1) + `,`,
 876                 `AggregationRule:` + strings.Replace(fmt.Sprintf("%v", this.AggregationRule), "AggregationRule", "AggregationRule", 1) + `,`,
 877                 `}`,
 878         }, "")
 879         return s
 880 }
 881 func (this *ClusterRoleBinding) String() string {
 882         if this == nil {
 883                 return "nil"
 884         }
 885         s := strings.Join([]string{`&ClusterRoleBinding{`,
 886                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 887                 `Subjects:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Subjects), "Subject", "Subject", 1), `&`, ``, 1) + `,`,
 888                 `RoleRef:` + strings.Replace(strings.Replace(this.RoleRef.String(), "RoleRef", "RoleRef", 1), `&`, ``, 1) + `,`,
 889                 `}`,
 890         }, "")
 891         return s
 892 }
 893 func (this *ClusterRoleBindingList) String() string {
 894         if this == nil {
 895                 return "nil"
 896         }
 897         s := strings.Join([]string{`&ClusterRoleBindingList{`,
 898                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 899                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ClusterRoleBinding", "ClusterRoleBinding", 1), `&`, ``, 1) + `,`,
 900                 `}`,
 901         }, "")
 902         return s
 903 }
 904 func (this *ClusterRoleList) String() string {
 905         if this == nil {
 906                 return "nil"
 907         }
 908         s := strings.Join([]string{`&ClusterRoleList{`,
 909                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 910                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ClusterRole", "ClusterRole", 1), `&`, ``, 1) + `,`,
 911                 `}`,
 912         }, "")
 913         return s
 914 }
 915 func (this *PolicyRule) String() string {
 916         if this == nil {
 917                 return "nil"
 918         }
 919         s := strings.Join([]string{`&PolicyRule{`,
 920                 `Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`,
 921                 `APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
 922                 `Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
 923                 `ResourceNames:` + fmt.Sprintf("%v", this.ResourceNames) + `,`,
 924                 `NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`,
 925                 `}`,
 926         }, "")
 927         return s
 928 }
 929 func (this *Role) String() string {
 930         if this == nil {
 931                 return "nil"
 932         }
 933         s := strings.Join([]string{`&Role{`,
 934                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 935                 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "PolicyRule", "PolicyRule", 1), `&`, ``, 1) + `,`,
 936                 `}`,
 937         }, "")
 938         return s
 939 }
 940 func (this *RoleBinding) String() string {
 941         if this == nil {
 942                 return "nil"
 943         }
 944         s := strings.Join([]string{`&RoleBinding{`,
 945                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 946                 `Subjects:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Subjects), "Subject", "Subject", 1), `&`, ``, 1) + `,`,
 947                 `RoleRef:` + strings.Replace(strings.Replace(this.RoleRef.String(), "RoleRef", "RoleRef", 1), `&`, ``, 1) + `,`,
 948                 `}`,
 949         }, "")
 950         return s
 951 }
 952 func (this *RoleBindingList) String() string {
 953         if this == nil {
 954                 return "nil"
 955         }
 956         s := strings.Join([]string{`&RoleBindingList{`,
 957                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 958                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "RoleBinding", "RoleBinding", 1), `&`, ``, 1) + `,`,
 959                 `}`,
 960         }, "")
 961         return s
 962 }
 963 func (this *RoleList) String() string {
 964         if this == nil {
 965                 return "nil"
 966         }
 967         s := strings.Join([]string{`&RoleList{`,
 968                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 969                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Role", "Role", 1), `&`, ``, 1) + `,`,
 970                 `}`,
 971         }, "")
 972         return s
 973 }
 974 func (this *RoleRef) String() string {
 975         if this == nil {
 976                 return "nil"
 977         }
 978         s := strings.Join([]string{`&RoleRef{`,
 979                 `APIGroup:` + fmt.Sprintf("%v", this.APIGroup) + `,`,
 980                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
 981                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
 982                 `}`,
 983         }, "")
 984         return s
 985 }
 986 func (this *Subject) String() string {
 987         if this == nil {
 988                 return "nil"
 989         }
 990         s := strings.Join([]string{`&Subject{`,
 991                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
 992                 `APIGroup:` + fmt.Sprintf("%v", this.APIGroup) + `,`,
 993                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
 994                 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
 995                 `}`,
 996         }, "")
 997         return s
 998 }
 999 func valueToStringGenerated(v interface{}) string {
1000         rv := reflect.ValueOf(v)
1001         if rv.IsNil() {
1002                 return "nil"
1003         }
1004         pv := reflect.Indirect(rv).Interface()
1005         return fmt.Sprintf("*%v", pv)
1006 }
1007 func (m *AggregationRule) Unmarshal(dAtA []byte) error {
1008         l := len(dAtA)
1009         iNdEx := 0
1010         for iNdEx < l {
1011                 preIndex := iNdEx
1012                 var wire uint64
1013                 for shift := uint(0); ; shift += 7 {
1014                         if shift >= 64 {
1015                                 return ErrIntOverflowGenerated
1016                         }
1017                         if iNdEx >= l {
1018                                 return io.ErrUnexpectedEOF
1019                         }
1020                         b := dAtA[iNdEx]
1021                         iNdEx++
1022                         wire |= (uint64(b) & 0x7F) << shift
1023                         if b < 0x80 {
1024                                 break
1025                         }
1026                 }
1027                 fieldNum := int32(wire >> 3)
1028                 wireType := int(wire & 0x7)
1029                 if wireType == 4 {
1030                         return fmt.Errorf("proto: AggregationRule: wiretype end group for non-group")
1031                 }
1032                 if fieldNum <= 0 {
1033                         return fmt.Errorf("proto: AggregationRule: illegal tag %d (wire type %d)", fieldNum, wire)
1034                 }
1035                 switch fieldNum {
1036                 case 1:
1037                         if wireType != 2 {
1038                                 return fmt.Errorf("proto: wrong wireType = %d for field ClusterRoleSelectors", wireType)
1039                         }
1040                         var msglen int
1041                         for shift := uint(0); ; shift += 7 {
1042                                 if shift >= 64 {
1043                                         return ErrIntOverflowGenerated
1044                                 }
1045                                 if iNdEx >= l {
1046                                         return io.ErrUnexpectedEOF
1047                                 }
1048                                 b := dAtA[iNdEx]
1049                                 iNdEx++
1050                                 msglen |= (int(b) & 0x7F) << shift
1051                                 if b < 0x80 {
1052                                         break
1053                                 }
1054                         }
1055                         if msglen < 0 {
1056                                 return ErrInvalidLengthGenerated
1057                         }
1058                         postIndex := iNdEx + msglen
1059                         if postIndex > l {
1060                                 return io.ErrUnexpectedEOF
1061                         }
1062                         m.ClusterRoleSelectors = append(m.ClusterRoleSelectors, k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{})
1063                         if err := m.ClusterRoleSelectors[len(m.ClusterRoleSelectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1064                                 return err
1065                         }
1066                         iNdEx = postIndex
1067                 default:
1068                         iNdEx = preIndex
1069                         skippy, err := skipGenerated(dAtA[iNdEx:])
1070                         if err != nil {
1071                                 return err
1072                         }
1073                         if skippy < 0 {
1074                                 return ErrInvalidLengthGenerated
1075                         }
1076                         if (iNdEx + skippy) > l {
1077                                 return io.ErrUnexpectedEOF
1078                         }
1079                         iNdEx += skippy
1080                 }
1081         }
1082
1083         if iNdEx > l {
1084                 return io.ErrUnexpectedEOF
1085         }
1086         return nil
1087 }
1088 func (m *ClusterRole) Unmarshal(dAtA []byte) error {
1089         l := len(dAtA)
1090         iNdEx := 0
1091         for iNdEx < l {
1092                 preIndex := iNdEx
1093                 var wire uint64
1094                 for shift := uint(0); ; shift += 7 {
1095                         if shift >= 64 {
1096                                 return ErrIntOverflowGenerated
1097                         }
1098                         if iNdEx >= l {
1099                                 return io.ErrUnexpectedEOF
1100                         }
1101                         b := dAtA[iNdEx]
1102                         iNdEx++
1103                         wire |= (uint64(b) & 0x7F) << shift
1104                         if b < 0x80 {
1105                                 break
1106                         }
1107                 }
1108                 fieldNum := int32(wire >> 3)
1109                 wireType := int(wire & 0x7)
1110                 if wireType == 4 {
1111                         return fmt.Errorf("proto: ClusterRole: wiretype end group for non-group")
1112                 }
1113                 if fieldNum <= 0 {
1114                         return fmt.Errorf("proto: ClusterRole: illegal tag %d (wire type %d)", fieldNum, wire)
1115                 }
1116                 switch fieldNum {
1117                 case 1:
1118                         if wireType != 2 {
1119                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1120                         }
1121                         var msglen int
1122                         for shift := uint(0); ; shift += 7 {
1123                                 if shift >= 64 {
1124                                         return ErrIntOverflowGenerated
1125                                 }
1126                                 if iNdEx >= l {
1127                                         return io.ErrUnexpectedEOF
1128                                 }
1129                                 b := dAtA[iNdEx]
1130                                 iNdEx++
1131                                 msglen |= (int(b) & 0x7F) << shift
1132                                 if b < 0x80 {
1133                                         break
1134                                 }
1135                         }
1136                         if msglen < 0 {
1137                                 return ErrInvalidLengthGenerated
1138                         }
1139                         postIndex := iNdEx + msglen
1140                         if postIndex > l {
1141                                 return io.ErrUnexpectedEOF
1142                         }
1143                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1144                                 return err
1145                         }
1146                         iNdEx = postIndex
1147                 case 2:
1148                         if wireType != 2 {
1149                                 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
1150                         }
1151                         var msglen int
1152                         for shift := uint(0); ; shift += 7 {
1153                                 if shift >= 64 {
1154                                         return ErrIntOverflowGenerated
1155                                 }
1156                                 if iNdEx >= l {
1157                                         return io.ErrUnexpectedEOF
1158                                 }
1159                                 b := dAtA[iNdEx]
1160                                 iNdEx++
1161                                 msglen |= (int(b) & 0x7F) << shift
1162                                 if b < 0x80 {
1163                                         break
1164                                 }
1165                         }
1166                         if msglen < 0 {
1167                                 return ErrInvalidLengthGenerated
1168                         }
1169                         postIndex := iNdEx + msglen
1170                         if postIndex > l {
1171                                 return io.ErrUnexpectedEOF
1172                         }
1173                         m.Rules = append(m.Rules, PolicyRule{})
1174                         if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1175                                 return err
1176                         }
1177                         iNdEx = postIndex
1178                 case 3:
1179                         if wireType != 2 {
1180                                 return fmt.Errorf("proto: wrong wireType = %d for field AggregationRule", wireType)
1181                         }
1182                         var msglen int
1183                         for shift := uint(0); ; shift += 7 {
1184                                 if shift >= 64 {
1185                                         return ErrIntOverflowGenerated
1186                                 }
1187                                 if iNdEx >= l {
1188                                         return io.ErrUnexpectedEOF
1189                                 }
1190                                 b := dAtA[iNdEx]
1191                                 iNdEx++
1192                                 msglen |= (int(b) & 0x7F) << shift
1193                                 if b < 0x80 {
1194                                         break
1195                                 }
1196                         }
1197                         if msglen < 0 {
1198                                 return ErrInvalidLengthGenerated
1199                         }
1200                         postIndex := iNdEx + msglen
1201                         if postIndex > l {
1202                                 return io.ErrUnexpectedEOF
1203                         }
1204                         if m.AggregationRule == nil {
1205                                 m.AggregationRule = &AggregationRule{}
1206                         }
1207                         if err := m.AggregationRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1208                                 return err
1209                         }
1210                         iNdEx = postIndex
1211                 default:
1212                         iNdEx = preIndex
1213                         skippy, err := skipGenerated(dAtA[iNdEx:])
1214                         if err != nil {
1215                                 return err
1216                         }
1217                         if skippy < 0 {
1218                                 return ErrInvalidLengthGenerated
1219                         }
1220                         if (iNdEx + skippy) > l {
1221                                 return io.ErrUnexpectedEOF
1222                         }
1223                         iNdEx += skippy
1224                 }
1225         }
1226
1227         if iNdEx > l {
1228                 return io.ErrUnexpectedEOF
1229         }
1230         return nil
1231 }
1232 func (m *ClusterRoleBinding) Unmarshal(dAtA []byte) error {
1233         l := len(dAtA)
1234         iNdEx := 0
1235         for iNdEx < l {
1236                 preIndex := iNdEx
1237                 var wire uint64
1238                 for shift := uint(0); ; shift += 7 {
1239                         if shift >= 64 {
1240                                 return ErrIntOverflowGenerated
1241                         }
1242                         if iNdEx >= l {
1243                                 return io.ErrUnexpectedEOF
1244                         }
1245                         b := dAtA[iNdEx]
1246                         iNdEx++
1247                         wire |= (uint64(b) & 0x7F) << shift
1248                         if b < 0x80 {
1249                                 break
1250                         }
1251                 }
1252                 fieldNum := int32(wire >> 3)
1253                 wireType := int(wire & 0x7)
1254                 if wireType == 4 {
1255                         return fmt.Errorf("proto: ClusterRoleBinding: wiretype end group for non-group")
1256                 }
1257                 if fieldNum <= 0 {
1258                         return fmt.Errorf("proto: ClusterRoleBinding: illegal tag %d (wire type %d)", fieldNum, wire)
1259                 }
1260                 switch fieldNum {
1261                 case 1:
1262                         if wireType != 2 {
1263                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1264                         }
1265                         var msglen int
1266                         for shift := uint(0); ; shift += 7 {
1267                                 if shift >= 64 {
1268                                         return ErrIntOverflowGenerated
1269                                 }
1270                                 if iNdEx >= l {
1271                                         return io.ErrUnexpectedEOF
1272                                 }
1273                                 b := dAtA[iNdEx]
1274                                 iNdEx++
1275                                 msglen |= (int(b) & 0x7F) << shift
1276                                 if b < 0x80 {
1277                                         break
1278                                 }
1279                         }
1280                         if msglen < 0 {
1281                                 return ErrInvalidLengthGenerated
1282                         }
1283                         postIndex := iNdEx + msglen
1284                         if postIndex > l {
1285                                 return io.ErrUnexpectedEOF
1286                         }
1287                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1288                                 return err
1289                         }
1290                         iNdEx = postIndex
1291                 case 2:
1292                         if wireType != 2 {
1293                                 return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType)
1294                         }
1295                         var msglen int
1296                         for shift := uint(0); ; shift += 7 {
1297                                 if shift >= 64 {
1298                                         return ErrIntOverflowGenerated
1299                                 }
1300                                 if iNdEx >= l {
1301                                         return io.ErrUnexpectedEOF
1302                                 }
1303                                 b := dAtA[iNdEx]
1304                                 iNdEx++
1305                                 msglen |= (int(b) & 0x7F) << shift
1306                                 if b < 0x80 {
1307                                         break
1308                                 }
1309                         }
1310                         if msglen < 0 {
1311                                 return ErrInvalidLengthGenerated
1312                         }
1313                         postIndex := iNdEx + msglen
1314                         if postIndex > l {
1315                                 return io.ErrUnexpectedEOF
1316                         }
1317                         m.Subjects = append(m.Subjects, Subject{})
1318                         if err := m.Subjects[len(m.Subjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1319                                 return err
1320                         }
1321                         iNdEx = postIndex
1322                 case 3:
1323                         if wireType != 2 {
1324                                 return fmt.Errorf("proto: wrong wireType = %d for field RoleRef", wireType)
1325                         }
1326                         var msglen int
1327                         for shift := uint(0); ; shift += 7 {
1328                                 if shift >= 64 {
1329                                         return ErrIntOverflowGenerated
1330                                 }
1331                                 if iNdEx >= l {
1332                                         return io.ErrUnexpectedEOF
1333                                 }
1334                                 b := dAtA[iNdEx]
1335                                 iNdEx++
1336                                 msglen |= (int(b) & 0x7F) << shift
1337                                 if b < 0x80 {
1338                                         break
1339                                 }
1340                         }
1341                         if msglen < 0 {
1342                                 return ErrInvalidLengthGenerated
1343                         }
1344                         postIndex := iNdEx + msglen
1345                         if postIndex > l {
1346                                 return io.ErrUnexpectedEOF
1347                         }
1348                         if err := m.RoleRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1349                                 return err
1350                         }
1351                         iNdEx = postIndex
1352                 default:
1353                         iNdEx = preIndex
1354                         skippy, err := skipGenerated(dAtA[iNdEx:])
1355                         if err != nil {
1356                                 return err
1357                         }
1358                         if skippy < 0 {
1359                                 return ErrInvalidLengthGenerated
1360                         }
1361                         if (iNdEx + skippy) > l {
1362                                 return io.ErrUnexpectedEOF
1363                         }
1364                         iNdEx += skippy
1365                 }
1366         }
1367
1368         if iNdEx > l {
1369                 return io.ErrUnexpectedEOF
1370         }
1371         return nil
1372 }
1373 func (m *ClusterRoleBindingList) Unmarshal(dAtA []byte) error {
1374         l := len(dAtA)
1375         iNdEx := 0
1376         for iNdEx < l {
1377                 preIndex := iNdEx
1378                 var wire uint64
1379                 for shift := uint(0); ; shift += 7 {
1380                         if shift >= 64 {
1381                                 return ErrIntOverflowGenerated
1382                         }
1383                         if iNdEx >= l {
1384                                 return io.ErrUnexpectedEOF
1385                         }
1386                         b := dAtA[iNdEx]
1387                         iNdEx++
1388                         wire |= (uint64(b) & 0x7F) << shift
1389                         if b < 0x80 {
1390                                 break
1391                         }
1392                 }
1393                 fieldNum := int32(wire >> 3)
1394                 wireType := int(wire & 0x7)
1395                 if wireType == 4 {
1396                         return fmt.Errorf("proto: ClusterRoleBindingList: wiretype end group for non-group")
1397                 }
1398                 if fieldNum <= 0 {
1399                         return fmt.Errorf("proto: ClusterRoleBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
1400                 }
1401                 switch fieldNum {
1402                 case 1:
1403                         if wireType != 2 {
1404                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1405                         }
1406                         var msglen int
1407                         for shift := uint(0); ; shift += 7 {
1408                                 if shift >= 64 {
1409                                         return ErrIntOverflowGenerated
1410                                 }
1411                                 if iNdEx >= l {
1412                                         return io.ErrUnexpectedEOF
1413                                 }
1414                                 b := dAtA[iNdEx]
1415                                 iNdEx++
1416                                 msglen |= (int(b) & 0x7F) << shift
1417                                 if b < 0x80 {
1418                                         break
1419                                 }
1420                         }
1421                         if msglen < 0 {
1422                                 return ErrInvalidLengthGenerated
1423                         }
1424                         postIndex := iNdEx + msglen
1425                         if postIndex > l {
1426                                 return io.ErrUnexpectedEOF
1427                         }
1428                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1429                                 return err
1430                         }
1431                         iNdEx = postIndex
1432                 case 2:
1433                         if wireType != 2 {
1434                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1435                         }
1436                         var msglen int
1437                         for shift := uint(0); ; shift += 7 {
1438                                 if shift >= 64 {
1439                                         return ErrIntOverflowGenerated
1440                                 }
1441                                 if iNdEx >= l {
1442                                         return io.ErrUnexpectedEOF
1443                                 }
1444                                 b := dAtA[iNdEx]
1445                                 iNdEx++
1446                                 msglen |= (int(b) & 0x7F) << shift
1447                                 if b < 0x80 {
1448                                         break
1449                                 }
1450                         }
1451                         if msglen < 0 {
1452                                 return ErrInvalidLengthGenerated
1453                         }
1454                         postIndex := iNdEx + msglen
1455                         if postIndex > l {
1456                                 return io.ErrUnexpectedEOF
1457                         }
1458                         m.Items = append(m.Items, ClusterRoleBinding{})
1459                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1460                                 return err
1461                         }
1462                         iNdEx = postIndex
1463                 default:
1464                         iNdEx = preIndex
1465                         skippy, err := skipGenerated(dAtA[iNdEx:])
1466                         if err != nil {
1467                                 return err
1468                         }
1469                         if skippy < 0 {
1470                                 return ErrInvalidLengthGenerated
1471                         }
1472                         if (iNdEx + skippy) > l {
1473                                 return io.ErrUnexpectedEOF
1474                         }
1475                         iNdEx += skippy
1476                 }
1477         }
1478
1479         if iNdEx > l {
1480                 return io.ErrUnexpectedEOF
1481         }
1482         return nil
1483 }
1484 func (m *ClusterRoleList) Unmarshal(dAtA []byte) error {
1485         l := len(dAtA)
1486         iNdEx := 0
1487         for iNdEx < l {
1488                 preIndex := iNdEx
1489                 var wire uint64
1490                 for shift := uint(0); ; shift += 7 {
1491                         if shift >= 64 {
1492                                 return ErrIntOverflowGenerated
1493                         }
1494                         if iNdEx >= l {
1495                                 return io.ErrUnexpectedEOF
1496                         }
1497                         b := dAtA[iNdEx]
1498                         iNdEx++
1499                         wire |= (uint64(b) & 0x7F) << shift
1500                         if b < 0x80 {
1501                                 break
1502                         }
1503                 }
1504                 fieldNum := int32(wire >> 3)
1505                 wireType := int(wire & 0x7)
1506                 if wireType == 4 {
1507                         return fmt.Errorf("proto: ClusterRoleList: wiretype end group for non-group")
1508                 }
1509                 if fieldNum <= 0 {
1510                         return fmt.Errorf("proto: ClusterRoleList: illegal tag %d (wire type %d)", fieldNum, wire)
1511                 }
1512                 switch fieldNum {
1513                 case 1:
1514                         if wireType != 2 {
1515                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1516                         }
1517                         var msglen int
1518                         for shift := uint(0); ; shift += 7 {
1519                                 if shift >= 64 {
1520                                         return ErrIntOverflowGenerated
1521                                 }
1522                                 if iNdEx >= l {
1523                                         return io.ErrUnexpectedEOF
1524                                 }
1525                                 b := dAtA[iNdEx]
1526                                 iNdEx++
1527                                 msglen |= (int(b) & 0x7F) << shift
1528                                 if b < 0x80 {
1529                                         break
1530                                 }
1531                         }
1532                         if msglen < 0 {
1533                                 return ErrInvalidLengthGenerated
1534                         }
1535                         postIndex := iNdEx + msglen
1536                         if postIndex > l {
1537                                 return io.ErrUnexpectedEOF
1538                         }
1539                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1540                                 return err
1541                         }
1542                         iNdEx = postIndex
1543                 case 2:
1544                         if wireType != 2 {
1545                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1546                         }
1547                         var msglen int
1548                         for shift := uint(0); ; shift += 7 {
1549                                 if shift >= 64 {
1550                                         return ErrIntOverflowGenerated
1551                                 }
1552                                 if iNdEx >= l {
1553                                         return io.ErrUnexpectedEOF
1554                                 }
1555                                 b := dAtA[iNdEx]
1556                                 iNdEx++
1557                                 msglen |= (int(b) & 0x7F) << shift
1558                                 if b < 0x80 {
1559                                         break
1560                                 }
1561                         }
1562                         if msglen < 0 {
1563                                 return ErrInvalidLengthGenerated
1564                         }
1565                         postIndex := iNdEx + msglen
1566                         if postIndex > l {
1567                                 return io.ErrUnexpectedEOF
1568                         }
1569                         m.Items = append(m.Items, ClusterRole{})
1570                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1571                                 return err
1572                         }
1573                         iNdEx = postIndex
1574                 default:
1575                         iNdEx = preIndex
1576                         skippy, err := skipGenerated(dAtA[iNdEx:])
1577                         if err != nil {
1578                                 return err
1579                         }
1580                         if skippy < 0 {
1581                                 return ErrInvalidLengthGenerated
1582                         }
1583                         if (iNdEx + skippy) > l {
1584                                 return io.ErrUnexpectedEOF
1585                         }
1586                         iNdEx += skippy
1587                 }
1588         }
1589
1590         if iNdEx > l {
1591                 return io.ErrUnexpectedEOF
1592         }
1593         return nil
1594 }
1595 func (m *PolicyRule) Unmarshal(dAtA []byte) error {
1596         l := len(dAtA)
1597         iNdEx := 0
1598         for iNdEx < l {
1599                 preIndex := iNdEx
1600                 var wire uint64
1601                 for shift := uint(0); ; shift += 7 {
1602                         if shift >= 64 {
1603                                 return ErrIntOverflowGenerated
1604                         }
1605                         if iNdEx >= l {
1606                                 return io.ErrUnexpectedEOF
1607                         }
1608                         b := dAtA[iNdEx]
1609                         iNdEx++
1610                         wire |= (uint64(b) & 0x7F) << shift
1611                         if b < 0x80 {
1612                                 break
1613                         }
1614                 }
1615                 fieldNum := int32(wire >> 3)
1616                 wireType := int(wire & 0x7)
1617                 if wireType == 4 {
1618                         return fmt.Errorf("proto: PolicyRule: wiretype end group for non-group")
1619                 }
1620                 if fieldNum <= 0 {
1621                         return fmt.Errorf("proto: PolicyRule: illegal tag %d (wire type %d)", fieldNum, wire)
1622                 }
1623                 switch fieldNum {
1624                 case 1:
1625                         if wireType != 2 {
1626                                 return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
1627                         }
1628                         var stringLen uint64
1629                         for shift := uint(0); ; shift += 7 {
1630                                 if shift >= 64 {
1631                                         return ErrIntOverflowGenerated
1632                                 }
1633                                 if iNdEx >= l {
1634                                         return io.ErrUnexpectedEOF
1635                                 }
1636                                 b := dAtA[iNdEx]
1637                                 iNdEx++
1638                                 stringLen |= (uint64(b) & 0x7F) << shift
1639                                 if b < 0x80 {
1640                                         break
1641                                 }
1642                         }
1643                         intStringLen := int(stringLen)
1644                         if intStringLen < 0 {
1645                                 return ErrInvalidLengthGenerated
1646                         }
1647                         postIndex := iNdEx + intStringLen
1648                         if postIndex > l {
1649                                 return io.ErrUnexpectedEOF
1650                         }
1651                         m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex]))
1652                         iNdEx = postIndex
1653                 case 2:
1654                         if wireType != 2 {
1655                                 return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
1656                         }
1657                         var stringLen uint64
1658                         for shift := uint(0); ; shift += 7 {
1659                                 if shift >= 64 {
1660                                         return ErrIntOverflowGenerated
1661                                 }
1662                                 if iNdEx >= l {
1663                                         return io.ErrUnexpectedEOF
1664                                 }
1665                                 b := dAtA[iNdEx]
1666                                 iNdEx++
1667                                 stringLen |= (uint64(b) & 0x7F) << shift
1668                                 if b < 0x80 {
1669                                         break
1670                                 }
1671                         }
1672                         intStringLen := int(stringLen)
1673                         if intStringLen < 0 {
1674                                 return ErrInvalidLengthGenerated
1675                         }
1676                         postIndex := iNdEx + intStringLen
1677                         if postIndex > l {
1678                                 return io.ErrUnexpectedEOF
1679                         }
1680                         m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
1681                         iNdEx = postIndex
1682                 case 3:
1683                         if wireType != 2 {
1684                                 return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
1685                         }
1686                         var stringLen uint64
1687                         for shift := uint(0); ; shift += 7 {
1688                                 if shift >= 64 {
1689                                         return ErrIntOverflowGenerated
1690                                 }
1691                                 if iNdEx >= l {
1692                                         return io.ErrUnexpectedEOF
1693                                 }
1694                                 b := dAtA[iNdEx]
1695                                 iNdEx++
1696                                 stringLen |= (uint64(b) & 0x7F) << shift
1697                                 if b < 0x80 {
1698                                         break
1699                                 }
1700                         }
1701                         intStringLen := int(stringLen)
1702                         if intStringLen < 0 {
1703                                 return ErrInvalidLengthGenerated
1704                         }
1705                         postIndex := iNdEx + intStringLen
1706                         if postIndex > l {
1707                                 return io.ErrUnexpectedEOF
1708                         }
1709                         m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
1710                         iNdEx = postIndex
1711                 case 4:
1712                         if wireType != 2 {
1713                                 return fmt.Errorf("proto: wrong wireType = %d for field ResourceNames", wireType)
1714                         }
1715                         var stringLen uint64
1716                         for shift := uint(0); ; shift += 7 {
1717                                 if shift >= 64 {
1718                                         return ErrIntOverflowGenerated
1719                                 }
1720                                 if iNdEx >= l {
1721                                         return io.ErrUnexpectedEOF
1722                                 }
1723                                 b := dAtA[iNdEx]
1724                                 iNdEx++
1725                                 stringLen |= (uint64(b) & 0x7F) << shift
1726                                 if b < 0x80 {
1727                                         break
1728                                 }
1729                         }
1730                         intStringLen := int(stringLen)
1731                         if intStringLen < 0 {
1732                                 return ErrInvalidLengthGenerated
1733                         }
1734                         postIndex := iNdEx + intStringLen
1735                         if postIndex > l {
1736                                 return io.ErrUnexpectedEOF
1737                         }
1738                         m.ResourceNames = append(m.ResourceNames, string(dAtA[iNdEx:postIndex]))
1739                         iNdEx = postIndex
1740                 case 5:
1741                         if wireType != 2 {
1742                                 return fmt.Errorf("proto: wrong wireType = %d for field NonResourceURLs", wireType)
1743                         }
1744                         var stringLen uint64
1745                         for shift := uint(0); ; shift += 7 {
1746                                 if shift >= 64 {
1747                                         return ErrIntOverflowGenerated
1748                                 }
1749                                 if iNdEx >= l {
1750                                         return io.ErrUnexpectedEOF
1751                                 }
1752                                 b := dAtA[iNdEx]
1753                                 iNdEx++
1754                                 stringLen |= (uint64(b) & 0x7F) << shift
1755                                 if b < 0x80 {
1756                                         break
1757                                 }
1758                         }
1759                         intStringLen := int(stringLen)
1760                         if intStringLen < 0 {
1761                                 return ErrInvalidLengthGenerated
1762                         }
1763                         postIndex := iNdEx + intStringLen
1764                         if postIndex > l {
1765                                 return io.ErrUnexpectedEOF
1766                         }
1767                         m.NonResourceURLs = append(m.NonResourceURLs, string(dAtA[iNdEx:postIndex]))
1768                         iNdEx = postIndex
1769                 default:
1770                         iNdEx = preIndex
1771                         skippy, err := skipGenerated(dAtA[iNdEx:])
1772                         if err != nil {
1773                                 return err
1774                         }
1775                         if skippy < 0 {
1776                                 return ErrInvalidLengthGenerated
1777                         }
1778                         if (iNdEx + skippy) > l {
1779                                 return io.ErrUnexpectedEOF
1780                         }
1781                         iNdEx += skippy
1782                 }
1783         }
1784
1785         if iNdEx > l {
1786                 return io.ErrUnexpectedEOF
1787         }
1788         return nil
1789 }
1790 func (m *Role) Unmarshal(dAtA []byte) error {
1791         l := len(dAtA)
1792         iNdEx := 0
1793         for iNdEx < l {
1794                 preIndex := iNdEx
1795                 var wire uint64
1796                 for shift := uint(0); ; shift += 7 {
1797                         if shift >= 64 {
1798                                 return ErrIntOverflowGenerated
1799                         }
1800                         if iNdEx >= l {
1801                                 return io.ErrUnexpectedEOF
1802                         }
1803                         b := dAtA[iNdEx]
1804                         iNdEx++
1805                         wire |= (uint64(b) & 0x7F) << shift
1806                         if b < 0x80 {
1807                                 break
1808                         }
1809                 }
1810                 fieldNum := int32(wire >> 3)
1811                 wireType := int(wire & 0x7)
1812                 if wireType == 4 {
1813                         return fmt.Errorf("proto: Role: wiretype end group for non-group")
1814                 }
1815                 if fieldNum <= 0 {
1816                         return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire)
1817                 }
1818                 switch fieldNum {
1819                 case 1:
1820                         if wireType != 2 {
1821                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1822                         }
1823                         var msglen int
1824                         for shift := uint(0); ; shift += 7 {
1825                                 if shift >= 64 {
1826                                         return ErrIntOverflowGenerated
1827                                 }
1828                                 if iNdEx >= l {
1829                                         return io.ErrUnexpectedEOF
1830                                 }
1831                                 b := dAtA[iNdEx]
1832                                 iNdEx++
1833                                 msglen |= (int(b) & 0x7F) << shift
1834                                 if b < 0x80 {
1835                                         break
1836                                 }
1837                         }
1838                         if msglen < 0 {
1839                                 return ErrInvalidLengthGenerated
1840                         }
1841                         postIndex := iNdEx + msglen
1842                         if postIndex > l {
1843                                 return io.ErrUnexpectedEOF
1844                         }
1845                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1846                                 return err
1847                         }
1848                         iNdEx = postIndex
1849                 case 2:
1850                         if wireType != 2 {
1851                                 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
1852                         }
1853                         var msglen int
1854                         for shift := uint(0); ; shift += 7 {
1855                                 if shift >= 64 {
1856                                         return ErrIntOverflowGenerated
1857                                 }
1858                                 if iNdEx >= l {
1859                                         return io.ErrUnexpectedEOF
1860                                 }
1861                                 b := dAtA[iNdEx]
1862                                 iNdEx++
1863                                 msglen |= (int(b) & 0x7F) << shift
1864                                 if b < 0x80 {
1865                                         break
1866                                 }
1867                         }
1868                         if msglen < 0 {
1869                                 return ErrInvalidLengthGenerated
1870                         }
1871                         postIndex := iNdEx + msglen
1872                         if postIndex > l {
1873                                 return io.ErrUnexpectedEOF
1874                         }
1875                         m.Rules = append(m.Rules, PolicyRule{})
1876                         if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1877                                 return err
1878                         }
1879                         iNdEx = postIndex
1880                 default:
1881                         iNdEx = preIndex
1882                         skippy, err := skipGenerated(dAtA[iNdEx:])
1883                         if err != nil {
1884                                 return err
1885                         }
1886                         if skippy < 0 {
1887                                 return ErrInvalidLengthGenerated
1888                         }
1889                         if (iNdEx + skippy) > l {
1890                                 return io.ErrUnexpectedEOF
1891                         }
1892                         iNdEx += skippy
1893                 }
1894         }
1895
1896         if iNdEx > l {
1897                 return io.ErrUnexpectedEOF
1898         }
1899         return nil
1900 }
1901 func (m *RoleBinding) Unmarshal(dAtA []byte) error {
1902         l := len(dAtA)
1903         iNdEx := 0
1904         for iNdEx < l {
1905                 preIndex := iNdEx
1906                 var wire uint64
1907                 for shift := uint(0); ; shift += 7 {
1908                         if shift >= 64 {
1909                                 return ErrIntOverflowGenerated
1910                         }
1911                         if iNdEx >= l {
1912                                 return io.ErrUnexpectedEOF
1913                         }
1914                         b := dAtA[iNdEx]
1915                         iNdEx++
1916                         wire |= (uint64(b) & 0x7F) << shift
1917                         if b < 0x80 {
1918                                 break
1919                         }
1920                 }
1921                 fieldNum := int32(wire >> 3)
1922                 wireType := int(wire & 0x7)
1923                 if wireType == 4 {
1924                         return fmt.Errorf("proto: RoleBinding: wiretype end group for non-group")
1925                 }
1926                 if fieldNum <= 0 {
1927                         return fmt.Errorf("proto: RoleBinding: illegal tag %d (wire type %d)", fieldNum, wire)
1928                 }
1929                 switch fieldNum {
1930                 case 1:
1931                         if wireType != 2 {
1932                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1933                         }
1934                         var msglen int
1935                         for shift := uint(0); ; shift += 7 {
1936                                 if shift >= 64 {
1937                                         return ErrIntOverflowGenerated
1938                                 }
1939                                 if iNdEx >= l {
1940                                         return io.ErrUnexpectedEOF
1941                                 }
1942                                 b := dAtA[iNdEx]
1943                                 iNdEx++
1944                                 msglen |= (int(b) & 0x7F) << shift
1945                                 if b < 0x80 {
1946                                         break
1947                                 }
1948                         }
1949                         if msglen < 0 {
1950                                 return ErrInvalidLengthGenerated
1951                         }
1952                         postIndex := iNdEx + msglen
1953                         if postIndex > l {
1954                                 return io.ErrUnexpectedEOF
1955                         }
1956                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1957                                 return err
1958                         }
1959                         iNdEx = postIndex
1960                 case 2:
1961                         if wireType != 2 {
1962                                 return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType)
1963                         }
1964                         var msglen int
1965                         for shift := uint(0); ; shift += 7 {
1966                                 if shift >= 64 {
1967                                         return ErrIntOverflowGenerated
1968                                 }
1969                                 if iNdEx >= l {
1970                                         return io.ErrUnexpectedEOF
1971                                 }
1972                                 b := dAtA[iNdEx]
1973                                 iNdEx++
1974                                 msglen |= (int(b) & 0x7F) << shift
1975                                 if b < 0x80 {
1976                                         break
1977                                 }
1978                         }
1979                         if msglen < 0 {
1980                                 return ErrInvalidLengthGenerated
1981                         }
1982                         postIndex := iNdEx + msglen
1983                         if postIndex > l {
1984                                 return io.ErrUnexpectedEOF
1985                         }
1986                         m.Subjects = append(m.Subjects, Subject{})
1987                         if err := m.Subjects[len(m.Subjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1988                                 return err
1989                         }
1990                         iNdEx = postIndex
1991                 case 3:
1992                         if wireType != 2 {
1993                                 return fmt.Errorf("proto: wrong wireType = %d for field RoleRef", wireType)
1994                         }
1995                         var msglen int
1996                         for shift := uint(0); ; shift += 7 {
1997                                 if shift >= 64 {
1998                                         return ErrIntOverflowGenerated
1999                                 }
2000                                 if iNdEx >= l {
2001                                         return io.ErrUnexpectedEOF
2002                                 }
2003                                 b := dAtA[iNdEx]
2004                                 iNdEx++
2005                                 msglen |= (int(b) & 0x7F) << shift
2006                                 if b < 0x80 {
2007                                         break
2008                                 }
2009                         }
2010                         if msglen < 0 {
2011                                 return ErrInvalidLengthGenerated
2012                         }
2013                         postIndex := iNdEx + msglen
2014                         if postIndex > l {
2015                                 return io.ErrUnexpectedEOF
2016                         }
2017                         if err := m.RoleRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2018                                 return err
2019                         }
2020                         iNdEx = postIndex
2021                 default:
2022                         iNdEx = preIndex
2023                         skippy, err := skipGenerated(dAtA[iNdEx:])
2024                         if err != nil {
2025                                 return err
2026                         }
2027                         if skippy < 0 {
2028                                 return ErrInvalidLengthGenerated
2029                         }
2030                         if (iNdEx + skippy) > l {
2031                                 return io.ErrUnexpectedEOF
2032                         }
2033                         iNdEx += skippy
2034                 }
2035         }
2036
2037         if iNdEx > l {
2038                 return io.ErrUnexpectedEOF
2039         }
2040         return nil
2041 }
2042 func (m *RoleBindingList) Unmarshal(dAtA []byte) error {
2043         l := len(dAtA)
2044         iNdEx := 0
2045         for iNdEx < l {
2046                 preIndex := iNdEx
2047                 var wire uint64
2048                 for shift := uint(0); ; shift += 7 {
2049                         if shift >= 64 {
2050                                 return ErrIntOverflowGenerated
2051                         }
2052                         if iNdEx >= l {
2053                                 return io.ErrUnexpectedEOF
2054                         }
2055                         b := dAtA[iNdEx]
2056                         iNdEx++
2057                         wire |= (uint64(b) & 0x7F) << shift
2058                         if b < 0x80 {
2059                                 break
2060                         }
2061                 }
2062                 fieldNum := int32(wire >> 3)
2063                 wireType := int(wire & 0x7)
2064                 if wireType == 4 {
2065                         return fmt.Errorf("proto: RoleBindingList: wiretype end group for non-group")
2066                 }
2067                 if fieldNum <= 0 {
2068                         return fmt.Errorf("proto: RoleBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
2069                 }
2070                 switch fieldNum {
2071                 case 1:
2072                         if wireType != 2 {
2073                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2074                         }
2075                         var msglen int
2076                         for shift := uint(0); ; shift += 7 {
2077                                 if shift >= 64 {
2078                                         return ErrIntOverflowGenerated
2079                                 }
2080                                 if iNdEx >= l {
2081                                         return io.ErrUnexpectedEOF
2082                                 }
2083                                 b := dAtA[iNdEx]
2084                                 iNdEx++
2085                                 msglen |= (int(b) & 0x7F) << shift
2086                                 if b < 0x80 {
2087                                         break
2088                                 }
2089                         }
2090                         if msglen < 0 {
2091                                 return ErrInvalidLengthGenerated
2092                         }
2093                         postIndex := iNdEx + msglen
2094                         if postIndex > l {
2095                                 return io.ErrUnexpectedEOF
2096                         }
2097                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2098                                 return err
2099                         }
2100                         iNdEx = postIndex
2101                 case 2:
2102                         if wireType != 2 {
2103                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2104                         }
2105                         var msglen int
2106                         for shift := uint(0); ; shift += 7 {
2107                                 if shift >= 64 {
2108                                         return ErrIntOverflowGenerated
2109                                 }
2110                                 if iNdEx >= l {
2111                                         return io.ErrUnexpectedEOF
2112                                 }
2113                                 b := dAtA[iNdEx]
2114                                 iNdEx++
2115                                 msglen |= (int(b) & 0x7F) << shift
2116                                 if b < 0x80 {
2117                                         break
2118                                 }
2119                         }
2120                         if msglen < 0 {
2121                                 return ErrInvalidLengthGenerated
2122                         }
2123                         postIndex := iNdEx + msglen
2124                         if postIndex > l {
2125                                 return io.ErrUnexpectedEOF
2126                         }
2127                         m.Items = append(m.Items, RoleBinding{})
2128                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2129                                 return err
2130                         }
2131                         iNdEx = postIndex
2132                 default:
2133                         iNdEx = preIndex
2134                         skippy, err := skipGenerated(dAtA[iNdEx:])
2135                         if err != nil {
2136                                 return err
2137                         }
2138                         if skippy < 0 {
2139                                 return ErrInvalidLengthGenerated
2140                         }
2141                         if (iNdEx + skippy) > l {
2142                                 return io.ErrUnexpectedEOF
2143                         }
2144                         iNdEx += skippy
2145                 }
2146         }
2147
2148         if iNdEx > l {
2149                 return io.ErrUnexpectedEOF
2150         }
2151         return nil
2152 }
2153 func (m *RoleList) Unmarshal(dAtA []byte) error {
2154         l := len(dAtA)
2155         iNdEx := 0
2156         for iNdEx < l {
2157                 preIndex := iNdEx
2158                 var wire uint64
2159                 for shift := uint(0); ; shift += 7 {
2160                         if shift >= 64 {
2161                                 return ErrIntOverflowGenerated
2162                         }
2163                         if iNdEx >= l {
2164                                 return io.ErrUnexpectedEOF
2165                         }
2166                         b := dAtA[iNdEx]
2167                         iNdEx++
2168                         wire |= (uint64(b) & 0x7F) << shift
2169                         if b < 0x80 {
2170                                 break
2171                         }
2172                 }
2173                 fieldNum := int32(wire >> 3)
2174                 wireType := int(wire & 0x7)
2175                 if wireType == 4 {
2176                         return fmt.Errorf("proto: RoleList: wiretype end group for non-group")
2177                 }
2178                 if fieldNum <= 0 {
2179                         return fmt.Errorf("proto: RoleList: illegal tag %d (wire type %d)", fieldNum, wire)
2180                 }
2181                 switch fieldNum {
2182                 case 1:
2183                         if wireType != 2 {
2184                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2185                         }
2186                         var msglen int
2187                         for shift := uint(0); ; shift += 7 {
2188                                 if shift >= 64 {
2189                                         return ErrIntOverflowGenerated
2190                                 }
2191                                 if iNdEx >= l {
2192                                         return io.ErrUnexpectedEOF
2193                                 }
2194                                 b := dAtA[iNdEx]
2195                                 iNdEx++
2196                                 msglen |= (int(b) & 0x7F) << shift
2197                                 if b < 0x80 {
2198                                         break
2199                                 }
2200                         }
2201                         if msglen < 0 {
2202                                 return ErrInvalidLengthGenerated
2203                         }
2204                         postIndex := iNdEx + msglen
2205                         if postIndex > l {
2206                                 return io.ErrUnexpectedEOF
2207                         }
2208                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2209                                 return err
2210                         }
2211                         iNdEx = postIndex
2212                 case 2:
2213                         if wireType != 2 {
2214                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2215                         }
2216                         var msglen int
2217                         for shift := uint(0); ; shift += 7 {
2218                                 if shift >= 64 {
2219                                         return ErrIntOverflowGenerated
2220                                 }
2221                                 if iNdEx >= l {
2222                                         return io.ErrUnexpectedEOF
2223                                 }
2224                                 b := dAtA[iNdEx]
2225                                 iNdEx++
2226                                 msglen |= (int(b) & 0x7F) << shift
2227                                 if b < 0x80 {
2228                                         break
2229                                 }
2230                         }
2231                         if msglen < 0 {
2232                                 return ErrInvalidLengthGenerated
2233                         }
2234                         postIndex := iNdEx + msglen
2235                         if postIndex > l {
2236                                 return io.ErrUnexpectedEOF
2237                         }
2238                         m.Items = append(m.Items, Role{})
2239                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2240                                 return err
2241                         }
2242                         iNdEx = postIndex
2243                 default:
2244                         iNdEx = preIndex
2245                         skippy, err := skipGenerated(dAtA[iNdEx:])
2246                         if err != nil {
2247                                 return err
2248                         }
2249                         if skippy < 0 {
2250                                 return ErrInvalidLengthGenerated
2251                         }
2252                         if (iNdEx + skippy) > l {
2253                                 return io.ErrUnexpectedEOF
2254                         }
2255                         iNdEx += skippy
2256                 }
2257         }
2258
2259         if iNdEx > l {
2260                 return io.ErrUnexpectedEOF
2261         }
2262         return nil
2263 }
2264 func (m *RoleRef) Unmarshal(dAtA []byte) error {
2265         l := len(dAtA)
2266         iNdEx := 0
2267         for iNdEx < l {
2268                 preIndex := iNdEx
2269                 var wire uint64
2270                 for shift := uint(0); ; shift += 7 {
2271                         if shift >= 64 {
2272                                 return ErrIntOverflowGenerated
2273                         }
2274                         if iNdEx >= l {
2275                                 return io.ErrUnexpectedEOF
2276                         }
2277                         b := dAtA[iNdEx]
2278                         iNdEx++
2279                         wire |= (uint64(b) & 0x7F) << shift
2280                         if b < 0x80 {
2281                                 break
2282                         }
2283                 }
2284                 fieldNum := int32(wire >> 3)
2285                 wireType := int(wire & 0x7)
2286                 if wireType == 4 {
2287                         return fmt.Errorf("proto: RoleRef: wiretype end group for non-group")
2288                 }
2289                 if fieldNum <= 0 {
2290                         return fmt.Errorf("proto: RoleRef: illegal tag %d (wire type %d)", fieldNum, wire)
2291                 }
2292                 switch fieldNum {
2293                 case 1:
2294                         if wireType != 2 {
2295                                 return fmt.Errorf("proto: wrong wireType = %d for field APIGroup", wireType)
2296                         }
2297                         var stringLen uint64
2298                         for shift := uint(0); ; shift += 7 {
2299                                 if shift >= 64 {
2300                                         return ErrIntOverflowGenerated
2301                                 }
2302                                 if iNdEx >= l {
2303                                         return io.ErrUnexpectedEOF
2304                                 }
2305                                 b := dAtA[iNdEx]
2306                                 iNdEx++
2307                                 stringLen |= (uint64(b) & 0x7F) << shift
2308                                 if b < 0x80 {
2309                                         break
2310                                 }
2311                         }
2312                         intStringLen := int(stringLen)
2313                         if intStringLen < 0 {
2314                                 return ErrInvalidLengthGenerated
2315                         }
2316                         postIndex := iNdEx + intStringLen
2317                         if postIndex > l {
2318                                 return io.ErrUnexpectedEOF
2319                         }
2320                         m.APIGroup = string(dAtA[iNdEx:postIndex])
2321                         iNdEx = postIndex
2322                 case 2:
2323                         if wireType != 2 {
2324                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
2325                         }
2326                         var stringLen uint64
2327                         for shift := uint(0); ; shift += 7 {
2328                                 if shift >= 64 {
2329                                         return ErrIntOverflowGenerated
2330                                 }
2331                                 if iNdEx >= l {
2332                                         return io.ErrUnexpectedEOF
2333                                 }
2334                                 b := dAtA[iNdEx]
2335                                 iNdEx++
2336                                 stringLen |= (uint64(b) & 0x7F) << shift
2337                                 if b < 0x80 {
2338                                         break
2339                                 }
2340                         }
2341                         intStringLen := int(stringLen)
2342                         if intStringLen < 0 {
2343                                 return ErrInvalidLengthGenerated
2344                         }
2345                         postIndex := iNdEx + intStringLen
2346                         if postIndex > l {
2347                                 return io.ErrUnexpectedEOF
2348                         }
2349                         m.Kind = string(dAtA[iNdEx:postIndex])
2350                         iNdEx = postIndex
2351                 case 3:
2352                         if wireType != 2 {
2353                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
2354                         }
2355                         var stringLen uint64
2356                         for shift := uint(0); ; shift += 7 {
2357                                 if shift >= 64 {
2358                                         return ErrIntOverflowGenerated
2359                                 }
2360                                 if iNdEx >= l {
2361                                         return io.ErrUnexpectedEOF
2362                                 }
2363                                 b := dAtA[iNdEx]
2364                                 iNdEx++
2365                                 stringLen |= (uint64(b) & 0x7F) << shift
2366                                 if b < 0x80 {
2367                                         break
2368                                 }
2369                         }
2370                         intStringLen := int(stringLen)
2371                         if intStringLen < 0 {
2372                                 return ErrInvalidLengthGenerated
2373                         }
2374                         postIndex := iNdEx + intStringLen
2375                         if postIndex > l {
2376                                 return io.ErrUnexpectedEOF
2377                         }
2378                         m.Name = string(dAtA[iNdEx:postIndex])
2379                         iNdEx = postIndex
2380                 default:
2381                         iNdEx = preIndex
2382                         skippy, err := skipGenerated(dAtA[iNdEx:])
2383                         if err != nil {
2384                                 return err
2385                         }
2386                         if skippy < 0 {
2387                                 return ErrInvalidLengthGenerated
2388                         }
2389                         if (iNdEx + skippy) > l {
2390                                 return io.ErrUnexpectedEOF
2391                         }
2392                         iNdEx += skippy
2393                 }
2394         }
2395
2396         if iNdEx > l {
2397                 return io.ErrUnexpectedEOF
2398         }
2399         return nil
2400 }
2401 func (m *Subject) Unmarshal(dAtA []byte) error {
2402         l := len(dAtA)
2403         iNdEx := 0
2404         for iNdEx < l {
2405                 preIndex := iNdEx
2406                 var wire uint64
2407                 for shift := uint(0); ; shift += 7 {
2408                         if shift >= 64 {
2409                                 return ErrIntOverflowGenerated
2410                         }
2411                         if iNdEx >= l {
2412                                 return io.ErrUnexpectedEOF
2413                         }
2414                         b := dAtA[iNdEx]
2415                         iNdEx++
2416                         wire |= (uint64(b) & 0x7F) << shift
2417                         if b < 0x80 {
2418                                 break
2419                         }
2420                 }
2421                 fieldNum := int32(wire >> 3)
2422                 wireType := int(wire & 0x7)
2423                 if wireType == 4 {
2424                         return fmt.Errorf("proto: Subject: wiretype end group for non-group")
2425                 }
2426                 if fieldNum <= 0 {
2427                         return fmt.Errorf("proto: Subject: illegal tag %d (wire type %d)", fieldNum, wire)
2428                 }
2429                 switch fieldNum {
2430                 case 1:
2431                         if wireType != 2 {
2432                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
2433                         }
2434                         var stringLen uint64
2435                         for shift := uint(0); ; shift += 7 {
2436                                 if shift >= 64 {
2437                                         return ErrIntOverflowGenerated
2438                                 }
2439                                 if iNdEx >= l {
2440                                         return io.ErrUnexpectedEOF
2441                                 }
2442                                 b := dAtA[iNdEx]
2443                                 iNdEx++
2444                                 stringLen |= (uint64(b) & 0x7F) << shift
2445                                 if b < 0x80 {
2446                                         break
2447                                 }
2448                         }
2449                         intStringLen := int(stringLen)
2450                         if intStringLen < 0 {
2451                                 return ErrInvalidLengthGenerated
2452                         }
2453                         postIndex := iNdEx + intStringLen
2454                         if postIndex > l {
2455                                 return io.ErrUnexpectedEOF
2456                         }
2457                         m.Kind = string(dAtA[iNdEx:postIndex])
2458                         iNdEx = postIndex
2459                 case 2:
2460                         if wireType != 2 {
2461                                 return fmt.Errorf("proto: wrong wireType = %d for field APIGroup", wireType)
2462                         }
2463                         var stringLen uint64
2464                         for shift := uint(0); ; shift += 7 {
2465                                 if shift >= 64 {
2466                                         return ErrIntOverflowGenerated
2467                                 }
2468                                 if iNdEx >= l {
2469                                         return io.ErrUnexpectedEOF
2470                                 }
2471                                 b := dAtA[iNdEx]
2472                                 iNdEx++
2473                                 stringLen |= (uint64(b) & 0x7F) << shift
2474                                 if b < 0x80 {
2475                                         break
2476                                 }
2477                         }
2478                         intStringLen := int(stringLen)
2479                         if intStringLen < 0 {
2480                                 return ErrInvalidLengthGenerated
2481                         }
2482                         postIndex := iNdEx + intStringLen
2483                         if postIndex > l {
2484                                 return io.ErrUnexpectedEOF
2485                         }
2486                         m.APIGroup = string(dAtA[iNdEx:postIndex])
2487                         iNdEx = postIndex
2488                 case 3:
2489                         if wireType != 2 {
2490                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
2491                         }
2492                         var stringLen uint64
2493                         for shift := uint(0); ; shift += 7 {
2494                                 if shift >= 64 {
2495                                         return ErrIntOverflowGenerated
2496                                 }
2497                                 if iNdEx >= l {
2498                                         return io.ErrUnexpectedEOF
2499                                 }
2500                                 b := dAtA[iNdEx]
2501                                 iNdEx++
2502                                 stringLen |= (uint64(b) & 0x7F) << shift
2503                                 if b < 0x80 {
2504                                         break
2505                                 }
2506                         }
2507                         intStringLen := int(stringLen)
2508                         if intStringLen < 0 {
2509                                 return ErrInvalidLengthGenerated
2510                         }
2511                         postIndex := iNdEx + intStringLen
2512                         if postIndex > l {
2513                                 return io.ErrUnexpectedEOF
2514                         }
2515                         m.Name = string(dAtA[iNdEx:postIndex])
2516                         iNdEx = postIndex
2517                 case 4:
2518                         if wireType != 2 {
2519                                 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
2520                         }
2521                         var stringLen uint64
2522                         for shift := uint(0); ; shift += 7 {
2523                                 if shift >= 64 {
2524                                         return ErrIntOverflowGenerated
2525                                 }
2526                                 if iNdEx >= l {
2527                                         return io.ErrUnexpectedEOF
2528                                 }
2529                                 b := dAtA[iNdEx]
2530                                 iNdEx++
2531                                 stringLen |= (uint64(b) & 0x7F) << shift
2532                                 if b < 0x80 {
2533                                         break
2534                                 }
2535                         }
2536                         intStringLen := int(stringLen)
2537                         if intStringLen < 0 {
2538                                 return ErrInvalidLengthGenerated
2539                         }
2540                         postIndex := iNdEx + intStringLen
2541                         if postIndex > l {
2542                                 return io.ErrUnexpectedEOF
2543                         }
2544                         m.Namespace = string(dAtA[iNdEx:postIndex])
2545                         iNdEx = postIndex
2546                 default:
2547                         iNdEx = preIndex
2548                         skippy, err := skipGenerated(dAtA[iNdEx:])
2549                         if err != nil {
2550                                 return err
2551                         }
2552                         if skippy < 0 {
2553                                 return ErrInvalidLengthGenerated
2554                         }
2555                         if (iNdEx + skippy) > l {
2556                                 return io.ErrUnexpectedEOF
2557                         }
2558                         iNdEx += skippy
2559                 }
2560         }
2561
2562         if iNdEx > l {
2563                 return io.ErrUnexpectedEOF
2564         }
2565         return nil
2566 }
2567 func skipGenerated(dAtA []byte) (n int, err error) {
2568         l := len(dAtA)
2569         iNdEx := 0
2570         for iNdEx < l {
2571                 var wire uint64
2572                 for shift := uint(0); ; shift += 7 {
2573                         if shift >= 64 {
2574                                 return 0, ErrIntOverflowGenerated
2575                         }
2576                         if iNdEx >= l {
2577                                 return 0, io.ErrUnexpectedEOF
2578                         }
2579                         b := dAtA[iNdEx]
2580                         iNdEx++
2581                         wire |= (uint64(b) & 0x7F) << shift
2582                         if b < 0x80 {
2583                                 break
2584                         }
2585                 }
2586                 wireType := int(wire & 0x7)
2587                 switch wireType {
2588                 case 0:
2589                         for shift := uint(0); ; shift += 7 {
2590                                 if shift >= 64 {
2591                                         return 0, ErrIntOverflowGenerated
2592                                 }
2593                                 if iNdEx >= l {
2594                                         return 0, io.ErrUnexpectedEOF
2595                                 }
2596                                 iNdEx++
2597                                 if dAtA[iNdEx-1] < 0x80 {
2598                                         break
2599                                 }
2600                         }
2601                         return iNdEx, nil
2602                 case 1:
2603                         iNdEx += 8
2604                         return iNdEx, nil
2605                 case 2:
2606                         var length int
2607                         for shift := uint(0); ; shift += 7 {
2608                                 if shift >= 64 {
2609                                         return 0, ErrIntOverflowGenerated
2610                                 }
2611                                 if iNdEx >= l {
2612                                         return 0, io.ErrUnexpectedEOF
2613                                 }
2614                                 b := dAtA[iNdEx]
2615                                 iNdEx++
2616                                 length |= (int(b) & 0x7F) << shift
2617                                 if b < 0x80 {
2618                                         break
2619                                 }
2620                         }
2621                         iNdEx += length
2622                         if length < 0 {
2623                                 return 0, ErrInvalidLengthGenerated
2624                         }
2625                         return iNdEx, nil
2626                 case 3:
2627                         for {
2628                                 var innerWire uint64
2629                                 var start int = iNdEx
2630                                 for shift := uint(0); ; shift += 7 {
2631                                         if shift >= 64 {
2632                                                 return 0, ErrIntOverflowGenerated
2633                                         }
2634                                         if iNdEx >= l {
2635                                                 return 0, io.ErrUnexpectedEOF
2636                                         }
2637                                         b := dAtA[iNdEx]
2638                                         iNdEx++
2639                                         innerWire |= (uint64(b) & 0x7F) << shift
2640                                         if b < 0x80 {
2641                                                 break
2642                                         }
2643                                 }
2644                                 innerWireType := int(innerWire & 0x7)
2645                                 if innerWireType == 4 {
2646                                         break
2647                                 }
2648                                 next, err := skipGenerated(dAtA[start:])
2649                                 if err != nil {
2650                                         return 0, err
2651                                 }
2652                                 iNdEx = start + next
2653                         }
2654                         return iNdEx, nil
2655                 case 4:
2656                         return iNdEx, nil
2657                 case 5:
2658                         iNdEx += 4
2659                         return iNdEx, nil
2660                 default:
2661                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2662                 }
2663         }
2664         panic("unreachable")
2665 }
2666
2667 var (
2668         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
2669         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
2670 )
2671
2672 func init() {
2673         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/rbac/v1/generated.proto", fileDescriptorGenerated)
2674 }
2675
2676 var fileDescriptorGenerated = []byte{
2677         // 807 bytes of a gzipped FileDescriptorProto
2678         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x55, 0xcf, 0x6f, 0xe3, 0x44,
2679         0x14, 0xce, 0xa4, 0x89, 0x1a, 0x4f, 0x88, 0x42, 0x87, 0x0a, 0x59, 0x05, 0x39, 0x95, 0x91, 0x50,
2680         0x25, 0xc0, 0x26, 0x05, 0x01, 0x12, 0xea, 0xa1, 0x2e, 0x02, 0x55, 0x2d, 0xa5, 0x9a, 0x0a, 0x0e,
2681         0x88, 0x03, 0x63, 0x67, 0xea, 0x0e, 0xf1, 0x2f, 0xcd, 0xd8, 0x91, 0x2a, 0x2e, 0x08, 0x89, 0x03,
2682         0xb7, 0x3d, 0xee, 0xfe, 0x05, 0x7b, 0xd9, 0x3d, 0xee, 0x5f, 0xb0, 0x97, 0x1e, 0x7b, 0xec, 0x29,
2683         0xda, 0x7a, 0xff, 0x90, 0x5d, 0xf9, 0x57, 0x9c, 0x1f, 0xee, 0x36, 0xa7, 0x48, 0xab, 0x3d, 0xb5,
2684         0xf3, 0xde, 0xf7, 0xbe, 0xf7, 0xcd, 0xe7, 0x79, 0x2f, 0xf0, 0xfb, 0xe1, 0x77, 0x42, 0x63, 0xbe,
2685         0x3e, 0x8c, 0x4c, 0xca, 0x3d, 0x1a, 0x52, 0xa1, 0x8f, 0xa8, 0x37, 0xf0, 0xb9, 0x9e, 0x27, 0x48,
2686         0xc0, 0x74, 0x6e, 0x12, 0x4b, 0x1f, 0xf5, 0x75, 0x9b, 0x7a, 0x94, 0x93, 0x90, 0x0e, 0xb4, 0x80,
2687         0xfb, 0xa1, 0x8f, 0x50, 0x86, 0xd1, 0x48, 0xc0, 0xb4, 0x04, 0xa3, 0x8d, 0xfa, 0x5b, 0x5f, 0xd8,
2688         0x2c, 0xbc, 0x88, 0x4c, 0xcd, 0xf2, 0x5d, 0xdd, 0xf6, 0x6d, 0x5f, 0x4f, 0xa1, 0x66, 0x74, 0x9e,
2689         0x9e, 0xd2, 0x43, 0xfa, 0x5f, 0x46, 0xb1, 0xf5, 0x75, 0xd9, 0xc6, 0x25, 0xd6, 0x05, 0xf3, 0x28,
2690         0xbf, 0xd4, 0x83, 0xa1, 0x9d, 0x04, 0x84, 0xee, 0xd2, 0x90, 0x54, 0x34, 0xde, 0xd2, 0xef, 0xaa,
2691         0xe2, 0x91, 0x17, 0x32, 0x97, 0x2e, 0x14, 0x7c, 0x73, 0x5f, 0x81, 0xb0, 0x2e, 0xa8, 0x4b, 0xe6,
2692         0xeb, 0xd4, 0x47, 0x00, 0x76, 0xf7, 0x6d, 0x9b, 0x53, 0x9b, 0x84, 0xcc, 0xf7, 0x70, 0xe4, 0x50,
2693         0xf4, 0x1f, 0x80, 0x9b, 0x96, 0x13, 0x89, 0x90, 0x72, 0xec, 0x3b, 0xf4, 0x8c, 0x3a, 0xd4, 0x0a,
2694         0x7d, 0x2e, 0x64, 0xb0, 0xbd, 0xb6, 0xd3, 0xde, 0xfd, 0x4a, 0x2b, 0x5d, 0x99, 0xf4, 0xd2, 0x82,
2695         0xa1, 0x9d, 0x04, 0x84, 0x96, 0x5c, 0x49, 0x1b, 0xf5, 0xb5, 0x63, 0x62, 0x52, 0xa7, 0xa8, 0x35,
2696         0x3e, 0xbe, 0x1a, 0xf7, 0x6a, 0xf1, 0xb8, 0xb7, 0x79, 0x50, 0x41, 0x8c, 0x2b, 0xdb, 0xa9, 0x0f,
2697         0xeb, 0xb0, 0x3d, 0x05, 0x47, 0x7f, 0xc2, 0x56, 0x42, 0x3e, 0x20, 0x21, 0x91, 0xc1, 0x36, 0xd8,
2698         0x69, 0xef, 0x7e, 0xb9, 0x9c, 0x94, 0x5f, 0xcc, 0xbf, 0xa8, 0x15, 0xfe, 0x4c, 0x43, 0x62, 0xa0,
2699         0x5c, 0x07, 0x2c, 0x63, 0x78, 0xc2, 0x8a, 0x0e, 0x60, 0x93, 0x47, 0x0e, 0x15, 0x72, 0x3d, 0xbd,
2700         0xa9, 0xa2, 0x2d, 0x7e, 0x7f, 0xed, 0xd4, 0x77, 0x98, 0x75, 0x99, 0x18, 0x65, 0x74, 0x72, 0xb2,
2701         0x66, 0x72, 0x12, 0x38, 0xab, 0x45, 0x26, 0xec, 0x92, 0x59, 0x47, 0xe5, 0xb5, 0x54, 0xed, 0x27,
2702         0x55, 0x74, 0x73, 0xe6, 0x1b, 0x1f, 0xc4, 0xe3, 0xde, 0xfc, 0x17, 0xc1, 0xf3, 0x84, 0xea, 0xff,
2703         0x75, 0x88, 0xa6, 0xac, 0x31, 0x98, 0x37, 0x60, 0x9e, 0xbd, 0x02, 0x87, 0x0e, 0x61, 0x4b, 0x44,
2704         0x69, 0xa2, 0x30, 0xe9, 0xa3, 0xaa, 0x5b, 0x9d, 0x65, 0x18, 0xe3, 0xfd, 0x9c, 0xac, 0x95, 0x07,
2705         0x04, 0x9e, 0x94, 0xa3, 0x1f, 0xe1, 0x3a, 0xf7, 0x1d, 0x8a, 0xe9, 0x79, 0xee, 0x4f, 0x25, 0x13,
2706         0xce, 0x20, 0x46, 0x37, 0x67, 0x5a, 0xcf, 0x03, 0xb8, 0x28, 0x56, 0x9f, 0x03, 0xf8, 0xe1, 0xa2,
2707         0x17, 0xc7, 0x4c, 0x84, 0xe8, 0x8f, 0x05, 0x3f, 0xb4, 0x25, 0x1f, 0x2f, 0x13, 0x99, 0x1b, 0x93,
2708         0x0b, 0x14, 0x91, 0x29, 0x2f, 0x8e, 0x60, 0x93, 0x85, 0xd4, 0x2d, 0x8c, 0xf8, 0xb4, 0x4a, 0xfe,
2709         0xa2, 0xb0, 0xf2, 0xd5, 0x1c, 0x26, 0xc5, 0x38, 0xe3, 0x50, 0x9f, 0x01, 0xd8, 0x9d, 0x02, 0xaf,
2710         0x40, 0xfe, 0x0f, 0xb3, 0xf2, 0x7b, 0xf7, 0xc9, 0xaf, 0xd6, 0xfd, 0x0a, 0x40, 0x58, 0x8e, 0x04,
2711         0xea, 0xc1, 0xe6, 0x88, 0x72, 0x33, 0xdb, 0x15, 0x92, 0x21, 0x25, 0xf8, 0xdf, 0x92, 0x00, 0xce,
2712         0xe2, 0xe8, 0x33, 0x28, 0x91, 0x80, 0xfd, 0xc4, 0xfd, 0x28, 0xc8, 0x3a, 0x4b, 0x46, 0x27, 0x1e,
2713         0xf7, 0xa4, 0xfd, 0xd3, 0xc3, 0x2c, 0x88, 0xcb, 0x7c, 0x02, 0xe6, 0x54, 0xf8, 0x11, 0xb7, 0xa8,
2714         0x90, 0xd7, 0x4a, 0x30, 0x2e, 0x82, 0xb8, 0xcc, 0xa3, 0x6f, 0x61, 0xa7, 0x38, 0x9c, 0x10, 0x97,
2715         0x0a, 0xb9, 0x91, 0x16, 0x6c, 0xc4, 0xe3, 0x5e, 0x07, 0x4f, 0x27, 0xf0, 0x2c, 0x0e, 0xed, 0xc1,
2716         0xae, 0xe7, 0x7b, 0x05, 0xe4, 0x57, 0x7c, 0x2c, 0xe4, 0x66, 0x5a, 0x9a, 0xce, 0xe2, 0xc9, 0x6c,
2717         0x0a, 0xcf, 0x63, 0xd5, 0xa7, 0x00, 0x36, 0xde, 0xa2, 0xfd, 0xa4, 0xfe, 0x5b, 0x87, 0xed, 0x77,
2718         0x7e, 0x69, 0x24, 0xe3, 0xb6, 0xda, 0x6d, 0xb1, 0xcc, 0xb8, 0xdd, 0xbf, 0x26, 0x1e, 0x03, 0xd8,
2719         0x5a, 0xd1, 0x7e, 0xd8, 0x9b, 0x15, 0x2c, 0xdf, 0x29, 0xb8, 0x5a, 0xe9, 0xdf, 0xb0, 0x70, 0x1d,
2720         0x7d, 0x0e, 0x5b, 0xc5, 0x4c, 0xa7, 0x3a, 0xa5, 0xb2, 0x6f, 0x31, 0xf6, 0x78, 0x82, 0x40, 0xdb,
2721         0xb0, 0x31, 0x64, 0xde, 0x40, 0xae, 0xa7, 0xc8, 0xf7, 0x72, 0x64, 0xe3, 0x88, 0x79, 0x03, 0x9c,
2722         0x66, 0x12, 0x84, 0x47, 0xdc, 0xec, 0x67, 0x75, 0x0a, 0x91, 0x4c, 0x33, 0x4e, 0x33, 0xea, 0x13,
2723         0x00, 0xd7, 0xf3, 0xd7, 0x33, 0xe1, 0x03, 0x77, 0xf2, 0x4d, 0xeb, 0xab, 0x2f, 0xa3, 0xef, 0xcd,
2724         0xdd, 0x91, 0x0e, 0xa5, 0xe4, 0xaf, 0x08, 0x88, 0x45, 0xe5, 0x46, 0x0a, 0xdb, 0xc8, 0x61, 0xd2,
2725         0x49, 0x91, 0xc0, 0x25, 0xc6, 0xd8, 0xb9, 0xba, 0x55, 0x6a, 0xd7, 0xb7, 0x4a, 0xed, 0xe6, 0x56,
2726         0xa9, 0xfd, 0x13, 0x2b, 0xe0, 0x2a, 0x56, 0xc0, 0x75, 0xac, 0x80, 0x9b, 0x58, 0x01, 0x2f, 0x62,
2727         0x05, 0x3c, 0x78, 0xa9, 0xd4, 0x7e, 0xaf, 0x8f, 0xfa, 0xaf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x24,
2728         0xa1, 0x47, 0x98, 0xcf, 0x0a, 0x00, 0x00,
2729 }