gerrit.onap Code Review - oom/registrator.git/blob

   1 /*
   2 Copyright 2016 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 // ************************************************************
  18 // DO NOT EDIT.
  19 // THIS FILE IS AUTO-GENERATED BY codecgen.
  20 // ************************************************************
  21
  22 package v1beta1
  23
  24 import (
  25         "errors"
  26         "fmt"
  27         codec1978 "github.com/ugorji/go/codec"
  28         pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
  29         "reflect"
  30         "runtime"
  31 )
  32
  33 const (
  34         // ----- content types ----
  35         codecSelferC_UTF81234 = 1
  36         codecSelferC_RAW1234  = 0
  37         // ----- value types used ----
  38         codecSelferValueTypeArray1234 = 10
  39         codecSelferValueTypeMap1234   = 9
  40         // ----- containerStateValues ----
  41         codecSelfer_containerMapKey1234    = 2
  42         codecSelfer_containerMapValue1234  = 3
  43         codecSelfer_containerMapEnd1234    = 4
  44         codecSelfer_containerArrayElem1234 = 6
  45         codecSelfer_containerArrayEnd1234  = 7
  46 )
  47
  48 var (
  49         codecSelferBitsize1234                         = uint8(reflect.TypeOf(uint(0)).Bits())
  50         codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
  51 )
  52
  53 type codecSelfer1234 struct{}
  54
  55 func init() {
  56         if codec1978.GenVersion != 5 {
  57                 _, file, _, _ := runtime.Caller(0)
  58                 err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
  59                         5, codec1978.GenVersion, file)
  60                 panic(err)
  61         }
  62         if false { // reference the types, but skip this branch at build/run time
  63                 var v0 pkg1_unversioned.TypeMeta
  64                 _ = v0
  65         }
  66 }
  67
  68 func (x *TokenReview) CodecEncodeSelf(e *codec1978.Encoder) {
  69         var h codecSelfer1234
  70         z, r := codec1978.GenHelperEncoder(e)
  71         _, _, _ = h, z, r
  72         if x == nil {
  73                 r.EncodeNil()
  74         } else {
  75                 yym1 := z.EncBinary()
  76                 _ = yym1
  77                 if false {
  78                 } else if z.HasExtensions() && z.EncExt(x) {
  79                 } else {
  80                         yysep2 := !z.EncBinary()
  81                         yy2arr2 := z.EncBasicHandle().StructToArray
  82                         var yyq2 [4]bool
  83                         _, _, _ = yysep2, yyq2, yy2arr2
  84                         const yyr2 bool = false
  85                         yyq2[1] = true
  86                         yyq2[2] = x.Kind != ""
  87                         yyq2[3] = x.APIVersion != ""
  88                         var yynn2 int
  89                         if yyr2 || yy2arr2 {
  90                                 r.EncodeArrayStart(4)
  91                         } else {
  92                                 yynn2 = 1
  93                                 for _, b := range yyq2 {
  94                                         if b {
  95                                                 yynn2++
  96                                         }
  97                                 }
  98                                 r.EncodeMapStart(yynn2)
  99                                 yynn2 = 0
 100                         }
 101                         if yyr2 || yy2arr2 {
 102                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 103                                 yy4 := &x.Spec
 104                                 yy4.CodecEncodeSelf(e)
 105                         } else {
 106                                 z.EncSendContainerState(codecSelfer_containerMapKey1234)
 107                                 r.EncodeString(codecSelferC_UTF81234, string("spec"))
 108                                 z.EncSendContainerState(codecSelfer_containerMapValue1234)
 109                                 yy6 := &x.Spec
 110                                 yy6.CodecEncodeSelf(e)
 111                         }
 112                         if yyr2 || yy2arr2 {
 113                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 114                                 if yyq2[1] {
 115                                         yy9 := &x.Status
 116                                         yy9.CodecEncodeSelf(e)
 117                                 } else {
 118                                         r.EncodeNil()
 119                                 }
 120                         } else {
 121                                 if yyq2[1] {
 122                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 123                                         r.EncodeString(codecSelferC_UTF81234, string("status"))
 124                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 125                                         yy11 := &x.Status
 126                                         yy11.CodecEncodeSelf(e)
 127                                 }
 128                         }
 129                         if yyr2 || yy2arr2 {
 130                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 131                                 if yyq2[2] {
 132                                         yym14 := z.EncBinary()
 133                                         _ = yym14
 134                                         if false {
 135                                         } else {
 136                                                 r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
 137                                         }
 138                                 } else {
 139                                         r.EncodeString(codecSelferC_UTF81234, "")
 140                                 }
 141                         } else {
 142                                 if yyq2[2] {
 143                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 144                                         r.EncodeString(codecSelferC_UTF81234, string("kind"))
 145                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 146                                         yym15 := z.EncBinary()
 147                                         _ = yym15
 148                                         if false {
 149                                         } else {
 150                                                 r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
 151                                         }
 152                                 }
 153                         }
 154                         if yyr2 || yy2arr2 {
 155                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 156                                 if yyq2[3] {
 157                                         yym17 := z.EncBinary()
 158                                         _ = yym17
 159                                         if false {
 160                                         } else {
 161                                                 r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
 162                                         }
 163                                 } else {
 164                                         r.EncodeString(codecSelferC_UTF81234, "")
 165                                 }
 166                         } else {
 167                                 if yyq2[3] {
 168                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 169                                         r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
 170                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 171                                         yym18 := z.EncBinary()
 172                                         _ = yym18
 173                                         if false {
 174                                         } else {
 175                                                 r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
 176                                         }
 177                                 }
 178                         }
 179                         if yyr2 || yy2arr2 {
 180                                 z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
 181                         } else {
 182                                 z.EncSendContainerState(codecSelfer_containerMapEnd1234)
 183                         }
 184                 }
 185         }
 186 }
 187
 188 func (x *TokenReview) CodecDecodeSelf(d *codec1978.Decoder) {
 189         var h codecSelfer1234
 190         z, r := codec1978.GenHelperDecoder(d)
 191         _, _, _ = h, z, r
 192         yym1 := z.DecBinary()
 193         _ = yym1
 194         if false {
 195         } else if z.HasExtensions() && z.DecExt(x) {
 196         } else {
 197                 yyct2 := r.ContainerType()
 198                 if yyct2 == codecSelferValueTypeMap1234 {
 199                         yyl2 := r.ReadMapStart()
 200                         if yyl2 == 0 {
 201                                 z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 202                         } else {
 203                                 x.codecDecodeSelfFromMap(yyl2, d)
 204                         }
 205                 } else if yyct2 == codecSelferValueTypeArray1234 {
 206                         yyl2 := r.ReadArrayStart()
 207                         if yyl2 == 0 {
 208                                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 209                         } else {
 210                                 x.codecDecodeSelfFromArray(yyl2, d)
 211                         }
 212                 } else {
 213                         panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
 214                 }
 215         }
 216 }
 217
 218 func (x *TokenReview) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 219         var h codecSelfer1234
 220         z, r := codec1978.GenHelperDecoder(d)
 221         _, _, _ = h, z, r
 222         var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 223         _ = yys3Slc
 224         var yyhl3 bool = l >= 0
 225         for yyj3 := 0; ; yyj3++ {
 226                 if yyhl3 {
 227                         if yyj3 >= l {
 228                                 break
 229                         }
 230                 } else {
 231                         if r.CheckBreak() {
 232                                 break
 233                         }
 234                 }
 235                 z.DecSendContainerState(codecSelfer_containerMapKey1234)
 236                 yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 237                 yys3 := string(yys3Slc)
 238                 z.DecSendContainerState(codecSelfer_containerMapValue1234)
 239                 switch yys3 {
 240                 case "spec":
 241                         if r.TryDecodeAsNil() {
 242                                 x.Spec = TokenReviewSpec{}
 243                         } else {
 244                                 yyv4 := &x.Spec
 245                                 yyv4.CodecDecodeSelf(d)
 246                         }
 247                 case "status":
 248                         if r.TryDecodeAsNil() {
 249                                 x.Status = TokenReviewStatus{}
 250                         } else {
 251                                 yyv5 := &x.Status
 252                                 yyv5.CodecDecodeSelf(d)
 253                         }
 254                 case "kind":
 255                         if r.TryDecodeAsNil() {
 256                                 x.Kind = ""
 257                         } else {
 258                                 x.Kind = string(r.DecodeString())
 259                         }
 260                 case "apiVersion":
 261                         if r.TryDecodeAsNil() {
 262                                 x.APIVersion = ""
 263                         } else {
 264                                 x.APIVersion = string(r.DecodeString())
 265                         }
 266                 default:
 267                         z.DecStructFieldNotFound(-1, yys3)
 268                 } // end switch yys3
 269         } // end for yyj3
 270         z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 271 }
 272
 273 func (x *TokenReview) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 274         var h codecSelfer1234
 275         z, r := codec1978.GenHelperDecoder(d)
 276         _, _, _ = h, z, r
 277         var yyj8 int
 278         var yyb8 bool
 279         var yyhl8 bool = l >= 0
 280         yyj8++
 281         if yyhl8 {
 282                 yyb8 = yyj8 > l
 283         } else {
 284                 yyb8 = r.CheckBreak()
 285         }
 286         if yyb8 {
 287                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 288                 return
 289         }
 290         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 291         if r.TryDecodeAsNil() {
 292                 x.Spec = TokenReviewSpec{}
 293         } else {
 294                 yyv9 := &x.Spec
 295                 yyv9.CodecDecodeSelf(d)
 296         }
 297         yyj8++
 298         if yyhl8 {
 299                 yyb8 = yyj8 > l
 300         } else {
 301                 yyb8 = r.CheckBreak()
 302         }
 303         if yyb8 {
 304                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 305                 return
 306         }
 307         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 308         if r.TryDecodeAsNil() {
 309                 x.Status = TokenReviewStatus{}
 310         } else {
 311                 yyv10 := &x.Status
 312                 yyv10.CodecDecodeSelf(d)
 313         }
 314         yyj8++
 315         if yyhl8 {
 316                 yyb8 = yyj8 > l
 317         } else {
 318                 yyb8 = r.CheckBreak()
 319         }
 320         if yyb8 {
 321                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 322                 return
 323         }
 324         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 325         if r.TryDecodeAsNil() {
 326                 x.Kind = ""
 327         } else {
 328                 x.Kind = string(r.DecodeString())
 329         }
 330         yyj8++
 331         if yyhl8 {
 332                 yyb8 = yyj8 > l
 333         } else {
 334                 yyb8 = r.CheckBreak()
 335         }
 336         if yyb8 {
 337                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 338                 return
 339         }
 340         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 341         if r.TryDecodeAsNil() {
 342                 x.APIVersion = ""
 343         } else {
 344                 x.APIVersion = string(r.DecodeString())
 345         }
 346         for {
 347                 yyj8++
 348                 if yyhl8 {
 349                         yyb8 = yyj8 > l
 350                 } else {
 351                         yyb8 = r.CheckBreak()
 352                 }
 353                 if yyb8 {
 354                         break
 355                 }
 356                 z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 357                 z.DecStructFieldNotFound(yyj8-1, "")
 358         }
 359         z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 360 }
 361
 362 func (x *TokenReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
 363         var h codecSelfer1234
 364         z, r := codec1978.GenHelperEncoder(e)
 365         _, _, _ = h, z, r
 366         if x == nil {
 367                 r.EncodeNil()
 368         } else {
 369                 yym1 := z.EncBinary()
 370                 _ = yym1
 371                 if false {
 372                 } else if z.HasExtensions() && z.EncExt(x) {
 373                 } else {
 374                         yysep2 := !z.EncBinary()
 375                         yy2arr2 := z.EncBasicHandle().StructToArray
 376                         var yyq2 [1]bool
 377                         _, _, _ = yysep2, yyq2, yy2arr2
 378                         const yyr2 bool = false
 379                         yyq2[0] = x.Token != ""
 380                         var yynn2 int
 381                         if yyr2 || yy2arr2 {
 382                                 r.EncodeArrayStart(1)
 383                         } else {
 384                                 yynn2 = 0
 385                                 for _, b := range yyq2 {
 386                                         if b {
 387                                                 yynn2++
 388                                         }
 389                                 }
 390                                 r.EncodeMapStart(yynn2)
 391                                 yynn2 = 0
 392                         }
 393                         if yyr2 || yy2arr2 {
 394                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 395                                 if yyq2[0] {
 396                                         yym4 := z.EncBinary()
 397                                         _ = yym4
 398                                         if false {
 399                                         } else {
 400                                                 r.EncodeString(codecSelferC_UTF81234, string(x.Token))
 401                                         }
 402                                 } else {
 403                                         r.EncodeString(codecSelferC_UTF81234, "")
 404                                 }
 405                         } else {
 406                                 if yyq2[0] {
 407                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 408                                         r.EncodeString(codecSelferC_UTF81234, string("token"))
 409                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 410                                         yym5 := z.EncBinary()
 411                                         _ = yym5
 412                                         if false {
 413                                         } else {
 414                                                 r.EncodeString(codecSelferC_UTF81234, string(x.Token))
 415                                         }
 416                                 }
 417                         }
 418                         if yyr2 || yy2arr2 {
 419                                 z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
 420                         } else {
 421                                 z.EncSendContainerState(codecSelfer_containerMapEnd1234)
 422                         }
 423                 }
 424         }
 425 }
 426
 427 func (x *TokenReviewSpec) CodecDecodeSelf(d *codec1978.Decoder) {
 428         var h codecSelfer1234
 429         z, r := codec1978.GenHelperDecoder(d)
 430         _, _, _ = h, z, r
 431         yym1 := z.DecBinary()
 432         _ = yym1
 433         if false {
 434         } else if z.HasExtensions() && z.DecExt(x) {
 435         } else {
 436                 yyct2 := r.ContainerType()
 437                 if yyct2 == codecSelferValueTypeMap1234 {
 438                         yyl2 := r.ReadMapStart()
 439                         if yyl2 == 0 {
 440                                 z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 441                         } else {
 442                                 x.codecDecodeSelfFromMap(yyl2, d)
 443                         }
 444                 } else if yyct2 == codecSelferValueTypeArray1234 {
 445                         yyl2 := r.ReadArrayStart()
 446                         if yyl2 == 0 {
 447                                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 448                         } else {
 449                                 x.codecDecodeSelfFromArray(yyl2, d)
 450                         }
 451                 } else {
 452                         panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
 453                 }
 454         }
 455 }
 456
 457 func (x *TokenReviewSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 458         var h codecSelfer1234
 459         z, r := codec1978.GenHelperDecoder(d)
 460         _, _, _ = h, z, r
 461         var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 462         _ = yys3Slc
 463         var yyhl3 bool = l >= 0
 464         for yyj3 := 0; ; yyj3++ {
 465                 if yyhl3 {
 466                         if yyj3 >= l {
 467                                 break
 468                         }
 469                 } else {
 470                         if r.CheckBreak() {
 471                                 break
 472                         }
 473                 }
 474                 z.DecSendContainerState(codecSelfer_containerMapKey1234)
 475                 yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 476                 yys3 := string(yys3Slc)
 477                 z.DecSendContainerState(codecSelfer_containerMapValue1234)
 478                 switch yys3 {
 479                 case "token":
 480                         if r.TryDecodeAsNil() {
 481                                 x.Token = ""
 482                         } else {
 483                                 x.Token = string(r.DecodeString())
 484                         }
 485                 default:
 486                         z.DecStructFieldNotFound(-1, yys3)
 487                 } // end switch yys3
 488         } // end for yyj3
 489         z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 490 }
 491
 492 func (x *TokenReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 493         var h codecSelfer1234
 494         z, r := codec1978.GenHelperDecoder(d)
 495         _, _, _ = h, z, r
 496         var yyj5 int
 497         var yyb5 bool
 498         var yyhl5 bool = l >= 0
 499         yyj5++
 500         if yyhl5 {
 501                 yyb5 = yyj5 > l
 502         } else {
 503                 yyb5 = r.CheckBreak()
 504         }
 505         if yyb5 {
 506                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 507                 return
 508         }
 509         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 510         if r.TryDecodeAsNil() {
 511                 x.Token = ""
 512         } else {
 513                 x.Token = string(r.DecodeString())
 514         }
 515         for {
 516                 yyj5++
 517                 if yyhl5 {
 518                         yyb5 = yyj5 > l
 519                 } else {
 520                         yyb5 = r.CheckBreak()
 521                 }
 522                 if yyb5 {
 523                         break
 524                 }
 525                 z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 526                 z.DecStructFieldNotFound(yyj5-1, "")
 527         }
 528         z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 529 }
 530
 531 func (x *TokenReviewStatus) CodecEncodeSelf(e *codec1978.Encoder) {
 532         var h codecSelfer1234
 533         z, r := codec1978.GenHelperEncoder(e)
 534         _, _, _ = h, z, r
 535         if x == nil {
 536                 r.EncodeNil()
 537         } else {
 538                 yym1 := z.EncBinary()
 539                 _ = yym1
 540                 if false {
 541                 } else if z.HasExtensions() && z.EncExt(x) {
 542                 } else {
 543                         yysep2 := !z.EncBinary()
 544                         yy2arr2 := z.EncBasicHandle().StructToArray
 545                         var yyq2 [2]bool
 546                         _, _, _ = yysep2, yyq2, yy2arr2
 547                         const yyr2 bool = false
 548                         yyq2[0] = x.Authenticated != false
 549                         yyq2[1] = true
 550                         var yynn2 int
 551                         if yyr2 || yy2arr2 {
 552                                 r.EncodeArrayStart(2)
 553                         } else {
 554                                 yynn2 = 0
 555                                 for _, b := range yyq2 {
 556                                         if b {
 557                                                 yynn2++
 558                                         }
 559                                 }
 560                                 r.EncodeMapStart(yynn2)
 561                                 yynn2 = 0
 562                         }
 563                         if yyr2 || yy2arr2 {
 564                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 565                                 if yyq2[0] {
 566                                         yym4 := z.EncBinary()
 567                                         _ = yym4
 568                                         if false {
 569                                         } else {
 570                                                 r.EncodeBool(bool(x.Authenticated))
 571                                         }
 572                                 } else {
 573                                         r.EncodeBool(false)
 574                                 }
 575                         } else {
 576                                 if yyq2[0] {
 577                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 578                                         r.EncodeString(codecSelferC_UTF81234, string("authenticated"))
 579                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 580                                         yym5 := z.EncBinary()
 581                                         _ = yym5
 582                                         if false {
 583                                         } else {
 584                                                 r.EncodeBool(bool(x.Authenticated))
 585                                         }
 586                                 }
 587                         }
 588                         if yyr2 || yy2arr2 {
 589                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 590                                 if yyq2[1] {
 591                                         yy7 := &x.User
 592                                         yy7.CodecEncodeSelf(e)
 593                                 } else {
 594                                         r.EncodeNil()
 595                                 }
 596                         } else {
 597                                 if yyq2[1] {
 598                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 599                                         r.EncodeString(codecSelferC_UTF81234, string("user"))
 600                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 601                                         yy9 := &x.User
 602                                         yy9.CodecEncodeSelf(e)
 603                                 }
 604                         }
 605                         if yyr2 || yy2arr2 {
 606                                 z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
 607                         } else {
 608                                 z.EncSendContainerState(codecSelfer_containerMapEnd1234)
 609                         }
 610                 }
 611         }
 612 }
 613
 614 func (x *TokenReviewStatus) CodecDecodeSelf(d *codec1978.Decoder) {
 615         var h codecSelfer1234
 616         z, r := codec1978.GenHelperDecoder(d)
 617         _, _, _ = h, z, r
 618         yym1 := z.DecBinary()
 619         _ = yym1
 620         if false {
 621         } else if z.HasExtensions() && z.DecExt(x) {
 622         } else {
 623                 yyct2 := r.ContainerType()
 624                 if yyct2 == codecSelferValueTypeMap1234 {
 625                         yyl2 := r.ReadMapStart()
 626                         if yyl2 == 0 {
 627                                 z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 628                         } else {
 629                                 x.codecDecodeSelfFromMap(yyl2, d)
 630                         }
 631                 } else if yyct2 == codecSelferValueTypeArray1234 {
 632                         yyl2 := r.ReadArrayStart()
 633                         if yyl2 == 0 {
 634                                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 635                         } else {
 636                                 x.codecDecodeSelfFromArray(yyl2, d)
 637                         }
 638                 } else {
 639                         panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
 640                 }
 641         }
 642 }
 643
 644 func (x *TokenReviewStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 645         var h codecSelfer1234
 646         z, r := codec1978.GenHelperDecoder(d)
 647         _, _, _ = h, z, r
 648         var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 649         _ = yys3Slc
 650         var yyhl3 bool = l >= 0
 651         for yyj3 := 0; ; yyj3++ {
 652                 if yyhl3 {
 653                         if yyj3 >= l {
 654                                 break
 655                         }
 656                 } else {
 657                         if r.CheckBreak() {
 658                                 break
 659                         }
 660                 }
 661                 z.DecSendContainerState(codecSelfer_containerMapKey1234)
 662                 yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 663                 yys3 := string(yys3Slc)
 664                 z.DecSendContainerState(codecSelfer_containerMapValue1234)
 665                 switch yys3 {
 666                 case "authenticated":
 667                         if r.TryDecodeAsNil() {
 668                                 x.Authenticated = false
 669                         } else {
 670                                 x.Authenticated = bool(r.DecodeBool())
 671                         }
 672                 case "user":
 673                         if r.TryDecodeAsNil() {
 674                                 x.User = UserInfo{}
 675                         } else {
 676                                 yyv5 := &x.User
 677                                 yyv5.CodecDecodeSelf(d)
 678                         }
 679                 default:
 680                         z.DecStructFieldNotFound(-1, yys3)
 681                 } // end switch yys3
 682         } // end for yyj3
 683         z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 684 }
 685
 686 func (x *TokenReviewStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 687         var h codecSelfer1234
 688         z, r := codec1978.GenHelperDecoder(d)
 689         _, _, _ = h, z, r
 690         var yyj6 int
 691         var yyb6 bool
 692         var yyhl6 bool = l >= 0
 693         yyj6++
 694         if yyhl6 {
 695                 yyb6 = yyj6 > l
 696         } else {
 697                 yyb6 = r.CheckBreak()
 698         }
 699         if yyb6 {
 700                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 701                 return
 702         }
 703         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 704         if r.TryDecodeAsNil() {
 705                 x.Authenticated = false
 706         } else {
 707                 x.Authenticated = bool(r.DecodeBool())
 708         }
 709         yyj6++
 710         if yyhl6 {
 711                 yyb6 = yyj6 > l
 712         } else {
 713                 yyb6 = r.CheckBreak()
 714         }
 715         if yyb6 {
 716                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 717                 return
 718         }
 719         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 720         if r.TryDecodeAsNil() {
 721                 x.User = UserInfo{}
 722         } else {
 723                 yyv8 := &x.User
 724                 yyv8.CodecDecodeSelf(d)
 725         }
 726         for {
 727                 yyj6++
 728                 if yyhl6 {
 729                         yyb6 = yyj6 > l
 730                 } else {
 731                         yyb6 = r.CheckBreak()
 732                 }
 733                 if yyb6 {
 734                         break
 735                 }
 736                 z.DecSendContainerState(codecSelfer_containerArrayElem1234)
 737                 z.DecStructFieldNotFound(yyj6-1, "")
 738         }
 739         z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 740 }
 741
 742 func (x *UserInfo) CodecEncodeSelf(e *codec1978.Encoder) {
 743         var h codecSelfer1234
 744         z, r := codec1978.GenHelperEncoder(e)
 745         _, _, _ = h, z, r
 746         if x == nil {
 747                 r.EncodeNil()
 748         } else {
 749                 yym1 := z.EncBinary()
 750                 _ = yym1
 751                 if false {
 752                 } else if z.HasExtensions() && z.EncExt(x) {
 753                 } else {
 754                         yysep2 := !z.EncBinary()
 755                         yy2arr2 := z.EncBasicHandle().StructToArray
 756                         var yyq2 [4]bool
 757                         _, _, _ = yysep2, yyq2, yy2arr2
 758                         const yyr2 bool = false
 759                         yyq2[0] = x.Username != ""
 760                         yyq2[1] = x.UID != ""
 761                         yyq2[2] = len(x.Groups) != 0
 762                         yyq2[3] = len(x.Extra) != 0
 763                         var yynn2 int
 764                         if yyr2 || yy2arr2 {
 765                                 r.EncodeArrayStart(4)
 766                         } else {
 767                                 yynn2 = 0
 768                                 for _, b := range yyq2 {
 769                                         if b {
 770                                                 yynn2++
 771                                         }
 772                                 }
 773                                 r.EncodeMapStart(yynn2)
 774                                 yynn2 = 0
 775                         }
 776                         if yyr2 || yy2arr2 {
 777                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 778                                 if yyq2[0] {
 779                                         yym4 := z.EncBinary()
 780                                         _ = yym4
 781                                         if false {
 782                                         } else {
 783                                                 r.EncodeString(codecSelferC_UTF81234, string(x.Username))
 784                                         }
 785                                 } else {
 786                                         r.EncodeString(codecSelferC_UTF81234, "")
 787                                 }
 788                         } else {
 789                                 if yyq2[0] {
 790                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 791                                         r.EncodeString(codecSelferC_UTF81234, string("username"))
 792                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 793                                         yym5 := z.EncBinary()
 794                                         _ = yym5
 795                                         if false {
 796                                         } else {
 797                                                 r.EncodeString(codecSelferC_UTF81234, string(x.Username))
 798                                         }
 799                                 }
 800                         }
 801                         if yyr2 || yy2arr2 {
 802                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 803                                 if yyq2[1] {
 804                                         yym7 := z.EncBinary()
 805                                         _ = yym7
 806                                         if false {
 807                                         } else {
 808                                                 r.EncodeString(codecSelferC_UTF81234, string(x.UID))
 809                                         }
 810                                 } else {
 811                                         r.EncodeString(codecSelferC_UTF81234, "")
 812                                 }
 813                         } else {
 814                                 if yyq2[1] {
 815                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 816                                         r.EncodeString(codecSelferC_UTF81234, string("uid"))
 817                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 818                                         yym8 := z.EncBinary()
 819                                         _ = yym8
 820                                         if false {
 821                                         } else {
 822                                                 r.EncodeString(codecSelferC_UTF81234, string(x.UID))
 823                                         }
 824                                 }
 825                         }
 826                         if yyr2 || yy2arr2 {
 827                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 828                                 if yyq2[2] {
 829                                         if x.Groups == nil {
 830                                                 r.EncodeNil()
 831                                         } else {
 832                                                 yym10 := z.EncBinary()
 833                                                 _ = yym10
 834                                                 if false {
 835                                                 } else {
 836                                                         z.F.EncSliceStringV(x.Groups, false, e)
 837                                                 }
 838                                         }
 839                                 } else {
 840                                         r.EncodeNil()
 841                                 }
 842                         } else {
 843                                 if yyq2[2] {
 844                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 845                                         r.EncodeString(codecSelferC_UTF81234, string("groups"))
 846                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 847                                         if x.Groups == nil {
 848                                                 r.EncodeNil()
 849                                         } else {
 850                                                 yym11 := z.EncBinary()
 851                                                 _ = yym11
 852                                                 if false {
 853                                                 } else {
 854                                                         z.F.EncSliceStringV(x.Groups, false, e)
 855                                                 }
 856                                         }
 857                                 }
 858                         }
 859                         if yyr2 || yy2arr2 {
 860                                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
 861                                 if yyq2[3] {
 862                                         if x.Extra == nil {
 863                                                 r.EncodeNil()
 864                                         } else {
 865                                                 yym13 := z.EncBinary()
 866                                                 _ = yym13
 867                                                 if false {
 868                                                 } else {
 869                                                         h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
 870                                                 }
 871                                         }
 872                                 } else {
 873                                         r.EncodeNil()
 874                                 }
 875                         } else {
 876                                 if yyq2[3] {
 877                                         z.EncSendContainerState(codecSelfer_containerMapKey1234)
 878                                         r.EncodeString(codecSelferC_UTF81234, string("extra"))
 879                                         z.EncSendContainerState(codecSelfer_containerMapValue1234)
 880                                         if x.Extra == nil {
 881                                                 r.EncodeNil()
 882                                         } else {
 883                                                 yym14 := z.EncBinary()
 884                                                 _ = yym14
 885                                                 if false {
 886                                                 } else {
 887                                                         h.encMapstringSlicestring((map[string][]string)(x.Extra), e)
 888                                                 }
 889                                         }
 890                                 }
 891                         }
 892                         if yyr2 || yy2arr2 {
 893                                 z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
 894                         } else {
 895                                 z.EncSendContainerState(codecSelfer_containerMapEnd1234)
 896                         }
 897                 }
 898         }
 899 }
 900
 901 func (x *UserInfo) CodecDecodeSelf(d *codec1978.Decoder) {
 902         var h codecSelfer1234
 903         z, r := codec1978.GenHelperDecoder(d)
 904         _, _, _ = h, z, r
 905         yym1 := z.DecBinary()
 906         _ = yym1
 907         if false {
 908         } else if z.HasExtensions() && z.DecExt(x) {
 909         } else {
 910                 yyct2 := r.ContainerType()
 911                 if yyct2 == codecSelferValueTypeMap1234 {
 912                         yyl2 := r.ReadMapStart()
 913                         if yyl2 == 0 {
 914                                 z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 915                         } else {
 916                                 x.codecDecodeSelfFromMap(yyl2, d)
 917                         }
 918                 } else if yyct2 == codecSelferValueTypeArray1234 {
 919                         yyl2 := r.ReadArrayStart()
 920                         if yyl2 == 0 {
 921                                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
 922                         } else {
 923                                 x.codecDecodeSelfFromArray(yyl2, d)
 924                         }
 925                 } else {
 926                         panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
 927                 }
 928         }
 929 }
 930
 931 func (x *UserInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 932         var h codecSelfer1234
 933         z, r := codec1978.GenHelperDecoder(d)
 934         _, _, _ = h, z, r
 935         var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 936         _ = yys3Slc
 937         var yyhl3 bool = l >= 0
 938         for yyj3 := 0; ; yyj3++ {
 939                 if yyhl3 {
 940                         if yyj3 >= l {
 941                                 break
 942                         }
 943                 } else {
 944                         if r.CheckBreak() {
 945                                 break
 946                         }
 947                 }
 948                 z.DecSendContainerState(codecSelfer_containerMapKey1234)
 949                 yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 950                 yys3 := string(yys3Slc)
 951                 z.DecSendContainerState(codecSelfer_containerMapValue1234)
 952                 switch yys3 {
 953                 case "username":
 954                         if r.TryDecodeAsNil() {
 955                                 x.Username = ""
 956                         } else {
 957                                 x.Username = string(r.DecodeString())
 958                         }
 959                 case "uid":
 960                         if r.TryDecodeAsNil() {
 961                                 x.UID = ""
 962                         } else {
 963                                 x.UID = string(r.DecodeString())
 964                         }
 965                 case "groups":
 966                         if r.TryDecodeAsNil() {
 967                                 x.Groups = nil
 968                         } else {
 969                                 yyv6 := &x.Groups
 970                                 yym7 := z.DecBinary()
 971                                 _ = yym7
 972                                 if false {
 973                                 } else {
 974                                         z.F.DecSliceStringX(yyv6, false, d)
 975                                 }
 976                         }
 977                 case "extra":
 978                         if r.TryDecodeAsNil() {
 979                                 x.Extra = nil
 980                         } else {
 981                                 yyv8 := &x.Extra
 982                                 yym9 := z.DecBinary()
 983                                 _ = yym9
 984                                 if false {
 985                                 } else {
 986                                         h.decMapstringSlicestring((*map[string][]string)(yyv8), d)
 987                                 }
 988                         }
 989                 default:
 990                         z.DecStructFieldNotFound(-1, yys3)
 991                 } // end switch yys3
 992         } // end for yyj3
 993         z.DecSendContainerState(codecSelfer_containerMapEnd1234)
 994 }
 995
 996 func (x *UserInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 997         var h codecSelfer1234
 998         z, r := codec1978.GenHelperDecoder(d)
 999         _, _, _ = h, z, r
1000         var yyj10 int
1001         var yyb10 bool
1002         var yyhl10 bool = l >= 0
1003         yyj10++
1004         if yyhl10 {
1005                 yyb10 = yyj10 > l
1006         } else {
1007                 yyb10 = r.CheckBreak()
1008         }
1009         if yyb10 {
1010                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
1011                 return
1012         }
1013         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
1014         if r.TryDecodeAsNil() {
1015                 x.Username = ""
1016         } else {
1017                 x.Username = string(r.DecodeString())
1018         }
1019         yyj10++
1020         if yyhl10 {
1021                 yyb10 = yyj10 > l
1022         } else {
1023                 yyb10 = r.CheckBreak()
1024         }
1025         if yyb10 {
1026                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
1027                 return
1028         }
1029         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
1030         if r.TryDecodeAsNil() {
1031                 x.UID = ""
1032         } else {
1033                 x.UID = string(r.DecodeString())
1034         }
1035         yyj10++
1036         if yyhl10 {
1037                 yyb10 = yyj10 > l
1038         } else {
1039                 yyb10 = r.CheckBreak()
1040         }
1041         if yyb10 {
1042                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
1043                 return
1044         }
1045         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
1046         if r.TryDecodeAsNil() {
1047                 x.Groups = nil
1048         } else {
1049                 yyv13 := &x.Groups
1050                 yym14 := z.DecBinary()
1051                 _ = yym14
1052                 if false {
1053                 } else {
1054                         z.F.DecSliceStringX(yyv13, false, d)
1055                 }
1056         }
1057         yyj10++
1058         if yyhl10 {
1059                 yyb10 = yyj10 > l
1060         } else {
1061                 yyb10 = r.CheckBreak()
1062         }
1063         if yyb10 {
1064                 z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
1065                 return
1066         }
1067         z.DecSendContainerState(codecSelfer_containerArrayElem1234)
1068         if r.TryDecodeAsNil() {
1069                 x.Extra = nil
1070         } else {
1071                 yyv15 := &x.Extra
1072                 yym16 := z.DecBinary()
1073                 _ = yym16
1074                 if false {
1075                 } else {
1076                         h.decMapstringSlicestring((*map[string][]string)(yyv15), d)
1077                 }
1078         }
1079         for {
1080                 yyj10++
1081                 if yyhl10 {
1082                         yyb10 = yyj10 > l
1083                 } else {
1084                         yyb10 = r.CheckBreak()
1085                 }
1086                 if yyb10 {
1087                         break
1088                 }
1089                 z.DecSendContainerState(codecSelfer_containerArrayElem1234)
1090                 z.DecStructFieldNotFound(yyj10-1, "")
1091         }
1092         z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
1093 }
1094
1095 func (x codecSelfer1234) encMapstringSlicestring(v map[string][]string, e *codec1978.Encoder) {
1096         var h codecSelfer1234
1097         z, r := codec1978.GenHelperEncoder(e)
1098         _, _, _ = h, z, r
1099         r.EncodeMapStart(len(v))
1100         for yyk1, yyv1 := range v {
1101                 z.EncSendContainerState(codecSelfer_containerMapKey1234)
1102                 yym2 := z.EncBinary()
1103                 _ = yym2
1104                 if false {
1105                 } else {
1106                         r.EncodeString(codecSelferC_UTF81234, string(yyk1))
1107                 }
1108                 z.EncSendContainerState(codecSelfer_containerMapValue1234)
1109                 if yyv1 == nil {
1110                         r.EncodeNil()
1111                 } else {
1112                         yym3 := z.EncBinary()
1113                         _ = yym3
1114                         if false {
1115                         } else {
1116                                 z.F.EncSliceStringV(yyv1, false, e)
1117                         }
1118                 }
1119         }
1120         z.EncSendContainerState(codecSelfer_containerMapEnd1234)
1121 }
1122
1123 func (x codecSelfer1234) decMapstringSlicestring(v *map[string][]string, d *codec1978.Decoder) {
1124         var h codecSelfer1234
1125         z, r := codec1978.GenHelperDecoder(d)
1126         _, _, _ = h, z, r
1127
1128         yyv1 := *v
1129         yyl1 := r.ReadMapStart()
1130         yybh1 := z.DecBasicHandle()
1131         if yyv1 == nil {
1132                 yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
1133                 yyv1 = make(map[string][]string, yyrl1)
1134                 *v = yyv1
1135         }
1136         var yymk1 string
1137         var yymv1 []string
1138         var yymg1 bool
1139         if yybh1.MapValueReset {
1140                 yymg1 = true
1141         }
1142         if yyl1 > 0 {
1143                 for yyj1 := 0; yyj1 < yyl1; yyj1++ {
1144                         z.DecSendContainerState(codecSelfer_containerMapKey1234)
1145                         if r.TryDecodeAsNil() {
1146                                 yymk1 = ""
1147                         } else {
1148                                 yymk1 = string(r.DecodeString())
1149                         }
1150
1151                         if yymg1 {
1152                                 yymv1 = yyv1[yymk1]
1153                         } else {
1154                                 yymv1 = nil
1155                         }
1156                         z.DecSendContainerState(codecSelfer_containerMapValue1234)
1157                         if r.TryDecodeAsNil() {
1158                                 yymv1 = nil
1159                         } else {
1160                                 yyv3 := &yymv1
1161                                 yym4 := z.DecBinary()
1162                                 _ = yym4
1163                                 if false {
1164                                 } else {
1165                                         z.F.DecSliceStringX(yyv3, false, d)
1166                                 }
1167                         }
1168
1169                         if yyv1 != nil {
1170                                 yyv1[yymk1] = yymv1
1171                         }
1172                 }
1173         } else if yyl1 < 0 {
1174                 for yyj1 := 0; !r.CheckBreak(); yyj1++ {
1175                         z.DecSendContainerState(codecSelfer_containerMapKey1234)
1176                         if r.TryDecodeAsNil() {
1177                                 yymk1 = ""
1178                         } else {
1179                                 yymk1 = string(r.DecodeString())
1180                         }
1181
1182                         if yymg1 {
1183                                 yymv1 = yyv1[yymk1]
1184                         } else {
1185                                 yymv1 = nil
1186                         }
1187                         z.DecSendContainerState(codecSelfer_containerMapValue1234)
1188                         if r.TryDecodeAsNil() {
1189                                 yymv1 = nil
1190                         } else {
1191                                 yyv6 := &yymv1
1192                                 yym7 := z.DecBinary()
1193                                 _ = yym7
1194                                 if false {
1195                                 } else {
1196                                         z.F.DecSliceStringX(yyv6, false, d)
1197                                 }
1198                         }
1199
1200                         if yyv1 != nil {
1201                                 yyv1[yymk1] = yymv1
1202                         }
1203                 }
1204         } // else len==0: TODO: Should we clear map entries?
1205         z.DecSendContainerState(codecSelfer_containerMapEnd1234)
1206 }
1207
1208 func (x codecSelfer1234) encSlicestring(v []string, e *codec1978.Encoder) {
1209         var h codecSelfer1234
1210         z, r := codec1978.GenHelperEncoder(e)
1211         _, _, _ = h, z, r
1212         r.EncodeArrayStart(len(v))
1213         for _, yyv1 := range v {
1214                 z.EncSendContainerState(codecSelfer_containerArrayElem1234)
1215                 yym2 := z.EncBinary()
1216                 _ = yym2
1217                 if false {
1218                 } else {
1219                         r.EncodeString(codecSelferC_UTF81234, string(yyv1))
1220                 }
1221         }
1222         z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
1223 }
1224
1225 func (x codecSelfer1234) decSlicestring(v *[]string, d *codec1978.Decoder) {
1226         var h codecSelfer1234
1227         z, r := codec1978.GenHelperDecoder(d)
1228         _, _, _ = h, z, r
1229
1230         yyv1 := *v
1231         yyh1, yyl1 := z.DecSliceHelperStart()
1232         var yyc1 bool
1233         _ = yyc1
1234         if yyl1 == 0 {
1235                 if yyv1 == nil {
1236                         yyv1 = []string{}
1237                         yyc1 = true
1238                 } else if len(yyv1) != 0 {
1239                         yyv1 = yyv1[:0]
1240                         yyc1 = true
1241                 }
1242         } else if yyl1 > 0 {
1243                 var yyrr1, yyrl1 int
1244                 var yyrt1 bool
1245                 _, _ = yyrl1, yyrt1
1246                 yyrr1 = yyl1 // len(yyv1)
1247                 if yyl1 > cap(yyv1) {
1248
1249                         yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
1250                         if yyrt1 {
1251                                 if yyrl1 <= cap(yyv1) {
1252                                         yyv1 = yyv1[:yyrl1]
1253                                 } else {
1254                                         yyv1 = make([]string, yyrl1)
1255                                 }
1256                         } else {
1257                                 yyv1 = make([]string, yyrl1)
1258                         }
1259                         yyc1 = true
1260                         yyrr1 = len(yyv1)
1261                 } else if yyl1 != len(yyv1) {
1262                         yyv1 = yyv1[:yyl1]
1263                         yyc1 = true
1264                 }
1265                 yyj1 := 0
1266                 for ; yyj1 < yyrr1; yyj1++ {
1267                         yyh1.ElemContainerState(yyj1)
1268                         if r.TryDecodeAsNil() {
1269                                 yyv1[yyj1] = ""
1270                         } else {
1271                                 yyv1[yyj1] = string(r.DecodeString())
1272                         }
1273
1274                 }
1275                 if yyrt1 {
1276                         for ; yyj1 < yyl1; yyj1++ {
1277                                 yyv1 = append(yyv1, "")
1278                                 yyh1.ElemContainerState(yyj1)
1279                                 if r.TryDecodeAsNil() {
1280                                         yyv1[yyj1] = ""
1281                                 } else {
1282                                         yyv1[yyj1] = string(r.DecodeString())
1283                                 }
1284
1285                         }
1286                 }
1287
1288         } else {
1289                 yyj1 := 0
1290                 for ; !r.CheckBreak(); yyj1++ {
1291
1292                         if yyj1 >= len(yyv1) {
1293                                 yyv1 = append(yyv1, "") // var yyz1 string
1294                                 yyc1 = true
1295                         }
1296                         yyh1.ElemContainerState(yyj1)
1297                         if yyj1 < len(yyv1) {
1298                                 if r.TryDecodeAsNil() {
1299                                         yyv1[yyj1] = ""
1300                                 } else {
1301                                         yyv1[yyj1] = string(r.DecodeString())
1302                                 }
1303
1304                         } else {
1305                                 z.DecSwallow()
1306                         }
1307
1308                 }
1309                 if yyj1 < len(yyv1) {
1310                         yyv1 = yyv1[:yyj1]
1311                         yyc1 = true
1312                 } else if yyj1 == 0 && yyv1 == nil {
1313                         yyv1 = []string{}
1314                         yyc1 = true
1315                 }
1316         }
1317         yyh1.End()
1318         if yyc1 {
1319                 *v = yyv1
1320         }
1321 }