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