vendor/github.com/gogo/protobuf/proto/wrappers.go

   1 // Protocol Buffers for Go with Gadgets
   2 //
   3 // Copyright (c) 2018, The GoGo Authors. All rights reserved.
   4 // http://github.com/gogo/protobuf
   5 //
   6 // Redistribution and use in source and binary forms, with or without
   7 // modification, are permitted provided that the following conditions are
   8 // met:
   9 //
  10 //     * Redistributions of source code must retain the above copyright
  11 // notice, this list of conditions and the following disclaimer.
  12 //     * Redistributions in binary form must reproduce the above
  13 // copyright notice, this list of conditions and the following disclaimer
  14 // in the documentation and/or other materials provided with the
  15 // distribution.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 package proto
  30
  31 import (
  32         "io"
  33         "reflect"
  34 )
  35
  36 func makeStdDoubleValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  37         return func(ptr pointer, tagsize int) int {
  38                         t := ptr.asPointerTo(u.typ).Interface().(*float64)
  39                         v := &float64Value{*t}
  40                         siz := Size(v)
  41                         return tagsize + SizeVarint(uint64(siz)) + siz
  42                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  43                         t := ptr.asPointerTo(u.typ).Interface().(*float64)
  44                         v := &float64Value{*t}
  45                         buf, err := Marshal(v)
  46                         if err != nil {
  47                                 return nil, err
  48                         }
  49                         b = appendVarint(b, wiretag)
  50                         b = appendVarint(b, uint64(len(buf)))
  51                         b = append(b, buf...)
  52                         return b, nil
  53                 }
  54 }
  55
  56 func makeStdDoubleValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  57         return func(ptr pointer, tagsize int) int {
  58                         if ptr.isNil() {
  59                                 return 0
  60                         }
  61                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
  62                         v := &float64Value{*t}
  63                         siz := Size(v)
  64                         return tagsize + SizeVarint(uint64(siz)) + siz
  65                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  66                         if ptr.isNil() {
  67                                 return b, nil
  68                         }
  69                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
  70                         v := &float64Value{*t}
  71                         buf, err := Marshal(v)
  72                         if err != nil {
  73                                 return nil, err
  74                         }
  75                         b = appendVarint(b, wiretag)
  76                         b = appendVarint(b, uint64(len(buf)))
  77                         b = append(b, buf...)
  78                         return b, nil
  79                 }
  80 }
  81
  82 func makeStdDoubleValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  83         return func(ptr pointer, tagsize int) int {
  84                         s := ptr.getSlice(u.typ)
  85                         n := 0
  86                         for i := 0; i < s.Len(); i++ {
  87                                 elem := s.Index(i)
  88                                 t := elem.Interface().(float64)
  89                                 v := &float64Value{t}
  90                                 siz := Size(v)
  91                                 n += siz + SizeVarint(uint64(siz)) + tagsize
  92                         }
  93                         return n
  94                 },
  95                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  96                         s := ptr.getSlice(u.typ)
  97                         for i := 0; i < s.Len(); i++ {
  98                                 elem := s.Index(i)
  99                                 t := elem.Interface().(float64)
 100                                 v := &float64Value{t}
 101                                 siz := Size(v)
 102                                 buf, err := Marshal(v)
 103                                 if err != nil {
 104                                         return nil, err
 105                                 }
 106                                 b = appendVarint(b, wiretag)
 107                                 b = appendVarint(b, uint64(siz))
 108                                 b = append(b, buf...)
 109                         }
 110
 111                         return b, nil
 112                 }
 113 }
 114
 115 func makeStdDoubleValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 116         return func(ptr pointer, tagsize int) int {
 117                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 118                         n := 0
 119                         for i := 0; i < s.Len(); i++ {
 120                                 elem := s.Index(i)
 121                                 t := elem.Interface().(*float64)
 122                                 v := &float64Value{*t}
 123                                 siz := Size(v)
 124                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 125                         }
 126                         return n
 127                 },
 128                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 129                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 130                         for i := 0; i < s.Len(); i++ {
 131                                 elem := s.Index(i)
 132                                 t := elem.Interface().(*float64)
 133                                 v := &float64Value{*t}
 134                                 siz := Size(v)
 135                                 buf, err := Marshal(v)
 136                                 if err != nil {
 137                                         return nil, err
 138                                 }
 139                                 b = appendVarint(b, wiretag)
 140                                 b = appendVarint(b, uint64(siz))
 141                                 b = append(b, buf...)
 142                         }
 143
 144                         return b, nil
 145                 }
 146 }
 147
 148 func makeStdDoubleValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 149         return func(b []byte, f pointer, w int) ([]byte, error) {
 150                 if w != WireBytes {
 151                         return nil, errInternalBadWireType
 152                 }
 153                 x, n := decodeVarint(b)
 154                 if n == 0 {
 155                         return nil, io.ErrUnexpectedEOF
 156                 }
 157                 b = b[n:]
 158                 if x > uint64(len(b)) {
 159                         return nil, io.ErrUnexpectedEOF
 160                 }
 161                 m := &float64Value{}
 162                 if err := Unmarshal(b[:x], m); err != nil {
 163                         return nil, err
 164                 }
 165                 s := f.asPointerTo(sub.typ).Elem()
 166                 s.Set(reflect.ValueOf(m.Value))
 167                 return b[x:], nil
 168         }
 169 }
 170
 171 func makeStdDoubleValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 172         return func(b []byte, f pointer, w int) ([]byte, error) {
 173                 if w != WireBytes {
 174                         return nil, errInternalBadWireType
 175                 }
 176                 x, n := decodeVarint(b)
 177                 if n == 0 {
 178                         return nil, io.ErrUnexpectedEOF
 179                 }
 180                 b = b[n:]
 181                 if x > uint64(len(b)) {
 182                         return nil, io.ErrUnexpectedEOF
 183                 }
 184                 m := &float64Value{}
 185                 if err := Unmarshal(b[:x], m); err != nil {
 186                         return nil, err
 187                 }
 188                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
 189                 s.Set(reflect.ValueOf(&m.Value))
 190                 return b[x:], nil
 191         }
 192 }
 193
 194 func makeStdDoubleValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 195         return func(b []byte, f pointer, w int) ([]byte, error) {
 196                 if w != WireBytes {
 197                         return nil, errInternalBadWireType
 198                 }
 199                 x, n := decodeVarint(b)
 200                 if n == 0 {
 201                         return nil, io.ErrUnexpectedEOF
 202                 }
 203                 b = b[n:]
 204                 if x > uint64(len(b)) {
 205                         return nil, io.ErrUnexpectedEOF
 206                 }
 207                 m := &float64Value{}
 208                 if err := Unmarshal(b[:x], m); err != nil {
 209                         return nil, err
 210                 }
 211                 slice := f.getSlice(reflect.PtrTo(sub.typ))
 212                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
 213                 slice.Set(newSlice)
 214                 return b[x:], nil
 215         }
 216 }
 217
 218 func makeStdDoubleValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 219         return func(b []byte, f pointer, w int) ([]byte, error) {
 220                 if w != WireBytes {
 221                         return nil, errInternalBadWireType
 222                 }
 223                 x, n := decodeVarint(b)
 224                 if n == 0 {
 225                         return nil, io.ErrUnexpectedEOF
 226                 }
 227                 b = b[n:]
 228                 if x > uint64(len(b)) {
 229                         return nil, io.ErrUnexpectedEOF
 230                 }
 231                 m := &float64Value{}
 232                 if err := Unmarshal(b[:x], m); err != nil {
 233                         return nil, err
 234                 }
 235                 slice := f.getSlice(sub.typ)
 236                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
 237                 slice.Set(newSlice)
 238                 return b[x:], nil
 239         }
 240 }
 241
 242 func makeStdFloatValueMarshaler(u *marshalInfo) (sizer, marshaler) {
 243         return func(ptr pointer, tagsize int) int {
 244                         t := ptr.asPointerTo(u.typ).Interface().(*float32)
 245                         v := &float32Value{*t}
 246                         siz := Size(v)
 247                         return tagsize + SizeVarint(uint64(siz)) + siz
 248                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 249                         t := ptr.asPointerTo(u.typ).Interface().(*float32)
 250                         v := &float32Value{*t}
 251                         buf, err := Marshal(v)
 252                         if err != nil {
 253                                 return nil, err
 254                         }
 255                         b = appendVarint(b, wiretag)
 256                         b = appendVarint(b, uint64(len(buf)))
 257                         b = append(b, buf...)
 258                         return b, nil
 259                 }
 260 }
 261
 262 func makeStdFloatValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
 263         return func(ptr pointer, tagsize int) int {
 264                         if ptr.isNil() {
 265                                 return 0
 266                         }
 267                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
 268                         v := &float32Value{*t}
 269                         siz := Size(v)
 270                         return tagsize + SizeVarint(uint64(siz)) + siz
 271                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 272                         if ptr.isNil() {
 273                                 return b, nil
 274                         }
 275                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
 276                         v := &float32Value{*t}
 277                         buf, err := Marshal(v)
 278                         if err != nil {
 279                                 return nil, err
 280                         }
 281                         b = appendVarint(b, wiretag)
 282                         b = appendVarint(b, uint64(len(buf)))
 283                         b = append(b, buf...)
 284                         return b, nil
 285                 }
 286 }
 287
 288 func makeStdFloatValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 289         return func(ptr pointer, tagsize int) int {
 290                         s := ptr.getSlice(u.typ)
 291                         n := 0
 292                         for i := 0; i < s.Len(); i++ {
 293                                 elem := s.Index(i)
 294                                 t := elem.Interface().(float32)
 295                                 v := &float32Value{t}
 296                                 siz := Size(v)
 297                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 298                         }
 299                         return n
 300                 },
 301                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 302                         s := ptr.getSlice(u.typ)
 303                         for i := 0; i < s.Len(); i++ {
 304                                 elem := s.Index(i)
 305                                 t := elem.Interface().(float32)
 306                                 v := &float32Value{t}
 307                                 siz := Size(v)
 308                                 buf, err := Marshal(v)
 309                                 if err != nil {
 310                                         return nil, err
 311                                 }
 312                                 b = appendVarint(b, wiretag)
 313                                 b = appendVarint(b, uint64(siz))
 314                                 b = append(b, buf...)
 315                         }
 316
 317                         return b, nil
 318                 }
 319 }
 320
 321 func makeStdFloatValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 322         return func(ptr pointer, tagsize int) int {
 323                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 324                         n := 0
 325                         for i := 0; i < s.Len(); i++ {
 326                                 elem := s.Index(i)
 327                                 t := elem.Interface().(*float32)
 328                                 v := &float32Value{*t}
 329                                 siz := Size(v)
 330                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 331                         }
 332                         return n
 333                 },
 334                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 335                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 336                         for i := 0; i < s.Len(); i++ {
 337                                 elem := s.Index(i)
 338                                 t := elem.Interface().(*float32)
 339                                 v := &float32Value{*t}
 340                                 siz := Size(v)
 341                                 buf, err := Marshal(v)
 342                                 if err != nil {
 343                                         return nil, err
 344                                 }
 345                                 b = appendVarint(b, wiretag)
 346                                 b = appendVarint(b, uint64(siz))
 347                                 b = append(b, buf...)
 348                         }
 349
 350                         return b, nil
 351                 }
 352 }
 353
 354 func makeStdFloatValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 355         return func(b []byte, f pointer, w int) ([]byte, error) {
 356                 if w != WireBytes {
 357                         return nil, errInternalBadWireType
 358                 }
 359                 x, n := decodeVarint(b)
 360                 if n == 0 {
 361                         return nil, io.ErrUnexpectedEOF
 362                 }
 363                 b = b[n:]
 364                 if x > uint64(len(b)) {
 365                         return nil, io.ErrUnexpectedEOF
 366                 }
 367                 m := &float32Value{}
 368                 if err := Unmarshal(b[:x], m); err != nil {
 369                         return nil, err
 370                 }
 371                 s := f.asPointerTo(sub.typ).Elem()
 372                 s.Set(reflect.ValueOf(m.Value))
 373                 return b[x:], nil
 374         }
 375 }
 376
 377 func makeStdFloatValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 378         return func(b []byte, f pointer, w int) ([]byte, error) {
 379                 if w != WireBytes {
 380                         return nil, errInternalBadWireType
 381                 }
 382                 x, n := decodeVarint(b)
 383                 if n == 0 {
 384                         return nil, io.ErrUnexpectedEOF
 385                 }
 386                 b = b[n:]
 387                 if x > uint64(len(b)) {
 388                         return nil, io.ErrUnexpectedEOF
 389                 }
 390                 m := &float32Value{}
 391                 if err := Unmarshal(b[:x], m); err != nil {
 392                         return nil, err
 393                 }
 394                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
 395                 s.Set(reflect.ValueOf(&m.Value))
 396                 return b[x:], nil
 397         }
 398 }
 399
 400 func makeStdFloatValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 401         return func(b []byte, f pointer, w int) ([]byte, error) {
 402                 if w != WireBytes {
 403                         return nil, errInternalBadWireType
 404                 }
 405                 x, n := decodeVarint(b)
 406                 if n == 0 {
 407                         return nil, io.ErrUnexpectedEOF
 408                 }
 409                 b = b[n:]
 410                 if x > uint64(len(b)) {
 411                         return nil, io.ErrUnexpectedEOF
 412                 }
 413                 m := &float32Value{}
 414                 if err := Unmarshal(b[:x], m); err != nil {
 415                         return nil, err
 416                 }
 417                 slice := f.getSlice(reflect.PtrTo(sub.typ))
 418                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
 419                 slice.Set(newSlice)
 420                 return b[x:], nil
 421         }
 422 }
 423
 424 func makeStdFloatValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 425         return func(b []byte, f pointer, w int) ([]byte, error) {
 426                 if w != WireBytes {
 427                         return nil, errInternalBadWireType
 428                 }
 429                 x, n := decodeVarint(b)
 430                 if n == 0 {
 431                         return nil, io.ErrUnexpectedEOF
 432                 }
 433                 b = b[n:]
 434                 if x > uint64(len(b)) {
 435                         return nil, io.ErrUnexpectedEOF
 436                 }
 437                 m := &float32Value{}
 438                 if err := Unmarshal(b[:x], m); err != nil {
 439                         return nil, err
 440                 }
 441                 slice := f.getSlice(sub.typ)
 442                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
 443                 slice.Set(newSlice)
 444                 return b[x:], nil
 445         }
 446 }
 447
 448 func makeStdInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
 449         return func(ptr pointer, tagsize int) int {
 450                         t := ptr.asPointerTo(u.typ).Interface().(*int64)
 451                         v := &int64Value{*t}
 452                         siz := Size(v)
 453                         return tagsize + SizeVarint(uint64(siz)) + siz
 454                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 455                         t := ptr.asPointerTo(u.typ).Interface().(*int64)
 456                         v := &int64Value{*t}
 457                         buf, err := Marshal(v)
 458                         if err != nil {
 459                                 return nil, err
 460                         }
 461                         b = appendVarint(b, wiretag)
 462                         b = appendVarint(b, uint64(len(buf)))
 463                         b = append(b, buf...)
 464                         return b, nil
 465                 }
 466 }
 467
 468 func makeStdInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
 469         return func(ptr pointer, tagsize int) int {
 470                         if ptr.isNil() {
 471                                 return 0
 472                         }
 473                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
 474                         v := &int64Value{*t}
 475                         siz := Size(v)
 476                         return tagsize + SizeVarint(uint64(siz)) + siz
 477                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 478                         if ptr.isNil() {
 479                                 return b, nil
 480                         }
 481                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
 482                         v := &int64Value{*t}
 483                         buf, err := Marshal(v)
 484                         if err != nil {
 485                                 return nil, err
 486                         }
 487                         b = appendVarint(b, wiretag)
 488                         b = appendVarint(b, uint64(len(buf)))
 489                         b = append(b, buf...)
 490                         return b, nil
 491                 }
 492 }
 493
 494 func makeStdInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 495         return func(ptr pointer, tagsize int) int {
 496                         s := ptr.getSlice(u.typ)
 497                         n := 0
 498                         for i := 0; i < s.Len(); i++ {
 499                                 elem := s.Index(i)
 500                                 t := elem.Interface().(int64)
 501                                 v := &int64Value{t}
 502                                 siz := Size(v)
 503                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 504                         }
 505                         return n
 506                 },
 507                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 508                         s := ptr.getSlice(u.typ)
 509                         for i := 0; i < s.Len(); i++ {
 510                                 elem := s.Index(i)
 511                                 t := elem.Interface().(int64)
 512                                 v := &int64Value{t}
 513                                 siz := Size(v)
 514                                 buf, err := Marshal(v)
 515                                 if err != nil {
 516                                         return nil, err
 517                                 }
 518                                 b = appendVarint(b, wiretag)
 519                                 b = appendVarint(b, uint64(siz))
 520                                 b = append(b, buf...)
 521                         }
 522
 523                         return b, nil
 524                 }
 525 }
 526
 527 func makeStdInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 528         return func(ptr pointer, tagsize int) int {
 529                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 530                         n := 0
 531                         for i := 0; i < s.Len(); i++ {
 532                                 elem := s.Index(i)
 533                                 t := elem.Interface().(*int64)
 534                                 v := &int64Value{*t}
 535                                 siz := Size(v)
 536                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 537                         }
 538                         return n
 539                 },
 540                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 541                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 542                         for i := 0; i < s.Len(); i++ {
 543                                 elem := s.Index(i)
 544                                 t := elem.Interface().(*int64)
 545                                 v := &int64Value{*t}
 546                                 siz := Size(v)
 547                                 buf, err := Marshal(v)
 548                                 if err != nil {
 549                                         return nil, err
 550                                 }
 551                                 b = appendVarint(b, wiretag)
 552                                 b = appendVarint(b, uint64(siz))
 553                                 b = append(b, buf...)
 554                         }
 555
 556                         return b, nil
 557                 }
 558 }
 559
 560 func makeStdInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 561         return func(b []byte, f pointer, w int) ([]byte, error) {
 562                 if w != WireBytes {
 563                         return nil, errInternalBadWireType
 564                 }
 565                 x, n := decodeVarint(b)
 566                 if n == 0 {
 567                         return nil, io.ErrUnexpectedEOF
 568                 }
 569                 b = b[n:]
 570                 if x > uint64(len(b)) {
 571                         return nil, io.ErrUnexpectedEOF
 572                 }
 573                 m := &int64Value{}
 574                 if err := Unmarshal(b[:x], m); err != nil {
 575                         return nil, err
 576                 }
 577                 s := f.asPointerTo(sub.typ).Elem()
 578                 s.Set(reflect.ValueOf(m.Value))
 579                 return b[x:], nil
 580         }
 581 }
 582
 583 func makeStdInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 584         return func(b []byte, f pointer, w int) ([]byte, error) {
 585                 if w != WireBytes {
 586                         return nil, errInternalBadWireType
 587                 }
 588                 x, n := decodeVarint(b)
 589                 if n == 0 {
 590                         return nil, io.ErrUnexpectedEOF
 591                 }
 592                 b = b[n:]
 593                 if x > uint64(len(b)) {
 594                         return nil, io.ErrUnexpectedEOF
 595                 }
 596                 m := &int64Value{}
 597                 if err := Unmarshal(b[:x], m); err != nil {
 598                         return nil, err
 599                 }
 600                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
 601                 s.Set(reflect.ValueOf(&m.Value))
 602                 return b[x:], nil
 603         }
 604 }
 605
 606 func makeStdInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 607         return func(b []byte, f pointer, w int) ([]byte, error) {
 608                 if w != WireBytes {
 609                         return nil, errInternalBadWireType
 610                 }
 611                 x, n := decodeVarint(b)
 612                 if n == 0 {
 613                         return nil, io.ErrUnexpectedEOF
 614                 }
 615                 b = b[n:]
 616                 if x > uint64(len(b)) {
 617                         return nil, io.ErrUnexpectedEOF
 618                 }
 619                 m := &int64Value{}
 620                 if err := Unmarshal(b[:x], m); err != nil {
 621                         return nil, err
 622                 }
 623                 slice := f.getSlice(reflect.PtrTo(sub.typ))
 624                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
 625                 slice.Set(newSlice)
 626                 return b[x:], nil
 627         }
 628 }
 629
 630 func makeStdInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 631         return func(b []byte, f pointer, w int) ([]byte, error) {
 632                 if w != WireBytes {
 633                         return nil, errInternalBadWireType
 634                 }
 635                 x, n := decodeVarint(b)
 636                 if n == 0 {
 637                         return nil, io.ErrUnexpectedEOF
 638                 }
 639                 b = b[n:]
 640                 if x > uint64(len(b)) {
 641                         return nil, io.ErrUnexpectedEOF
 642                 }
 643                 m := &int64Value{}
 644                 if err := Unmarshal(b[:x], m); err != nil {
 645                         return nil, err
 646                 }
 647                 slice := f.getSlice(sub.typ)
 648                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
 649                 slice.Set(newSlice)
 650                 return b[x:], nil
 651         }
 652 }
 653
 654 func makeStdUInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
 655         return func(ptr pointer, tagsize int) int {
 656                         t := ptr.asPointerTo(u.typ).Interface().(*uint64)
 657                         v := &uint64Value{*t}
 658                         siz := Size(v)
 659                         return tagsize + SizeVarint(uint64(siz)) + siz
 660                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 661                         t := ptr.asPointerTo(u.typ).Interface().(*uint64)
 662                         v := &uint64Value{*t}
 663                         buf, err := Marshal(v)
 664                         if err != nil {
 665                                 return nil, err
 666                         }
 667                         b = appendVarint(b, wiretag)
 668                         b = appendVarint(b, uint64(len(buf)))
 669                         b = append(b, buf...)
 670                         return b, nil
 671                 }
 672 }
 673
 674 func makeStdUInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
 675         return func(ptr pointer, tagsize int) int {
 676                         if ptr.isNil() {
 677                                 return 0
 678                         }
 679                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
 680                         v := &uint64Value{*t}
 681                         siz := Size(v)
 682                         return tagsize + SizeVarint(uint64(siz)) + siz
 683                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 684                         if ptr.isNil() {
 685                                 return b, nil
 686                         }
 687                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
 688                         v := &uint64Value{*t}
 689                         buf, err := Marshal(v)
 690                         if err != nil {
 691                                 return nil, err
 692                         }
 693                         b = appendVarint(b, wiretag)
 694                         b = appendVarint(b, uint64(len(buf)))
 695                         b = append(b, buf...)
 696                         return b, nil
 697                 }
 698 }
 699
 700 func makeStdUInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 701         return func(ptr pointer, tagsize int) int {
 702                         s := ptr.getSlice(u.typ)
 703                         n := 0
 704                         for i := 0; i < s.Len(); i++ {
 705                                 elem := s.Index(i)
 706                                 t := elem.Interface().(uint64)
 707                                 v := &uint64Value{t}
 708                                 siz := Size(v)
 709                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 710                         }
 711                         return n
 712                 },
 713                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 714                         s := ptr.getSlice(u.typ)
 715                         for i := 0; i < s.Len(); i++ {
 716                                 elem := s.Index(i)
 717                                 t := elem.Interface().(uint64)
 718                                 v := &uint64Value{t}
 719                                 siz := Size(v)
 720                                 buf, err := Marshal(v)
 721                                 if err != nil {
 722                                         return nil, err
 723                                 }
 724                                 b = appendVarint(b, wiretag)
 725                                 b = appendVarint(b, uint64(siz))
 726                                 b = append(b, buf...)
 727                         }
 728
 729                         return b, nil
 730                 }
 731 }
 732
 733 func makeStdUInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 734         return func(ptr pointer, tagsize int) int {
 735                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 736                         n := 0
 737                         for i := 0; i < s.Len(); i++ {
 738                                 elem := s.Index(i)
 739                                 t := elem.Interface().(*uint64)
 740                                 v := &uint64Value{*t}
 741                                 siz := Size(v)
 742                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 743                         }
 744                         return n
 745                 },
 746                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 747                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 748                         for i := 0; i < s.Len(); i++ {
 749                                 elem := s.Index(i)
 750                                 t := elem.Interface().(*uint64)
 751                                 v := &uint64Value{*t}
 752                                 siz := Size(v)
 753                                 buf, err := Marshal(v)
 754                                 if err != nil {
 755                                         return nil, err
 756                                 }
 757                                 b = appendVarint(b, wiretag)
 758                                 b = appendVarint(b, uint64(siz))
 759                                 b = append(b, buf...)
 760                         }
 761
 762                         return b, nil
 763                 }
 764 }
 765
 766 func makeStdUInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 767         return func(b []byte, f pointer, w int) ([]byte, error) {
 768                 if w != WireBytes {
 769                         return nil, errInternalBadWireType
 770                 }
 771                 x, n := decodeVarint(b)
 772                 if n == 0 {
 773                         return nil, io.ErrUnexpectedEOF
 774                 }
 775                 b = b[n:]
 776                 if x > uint64(len(b)) {
 777                         return nil, io.ErrUnexpectedEOF
 778                 }
 779                 m := &uint64Value{}
 780                 if err := Unmarshal(b[:x], m); err != nil {
 781                         return nil, err
 782                 }
 783                 s := f.asPointerTo(sub.typ).Elem()
 784                 s.Set(reflect.ValueOf(m.Value))
 785                 return b[x:], nil
 786         }
 787 }
 788
 789 func makeStdUInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 790         return func(b []byte, f pointer, w int) ([]byte, error) {
 791                 if w != WireBytes {
 792                         return nil, errInternalBadWireType
 793                 }
 794                 x, n := decodeVarint(b)
 795                 if n == 0 {
 796                         return nil, io.ErrUnexpectedEOF
 797                 }
 798                 b = b[n:]
 799                 if x > uint64(len(b)) {
 800                         return nil, io.ErrUnexpectedEOF
 801                 }
 802                 m := &uint64Value{}
 803                 if err := Unmarshal(b[:x], m); err != nil {
 804                         return nil, err
 805                 }
 806                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
 807                 s.Set(reflect.ValueOf(&m.Value))
 808                 return b[x:], nil
 809         }
 810 }
 811
 812 func makeStdUInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 813         return func(b []byte, f pointer, w int) ([]byte, error) {
 814                 if w != WireBytes {
 815                         return nil, errInternalBadWireType
 816                 }
 817                 x, n := decodeVarint(b)
 818                 if n == 0 {
 819                         return nil, io.ErrUnexpectedEOF
 820                 }
 821                 b = b[n:]
 822                 if x > uint64(len(b)) {
 823                         return nil, io.ErrUnexpectedEOF
 824                 }
 825                 m := &uint64Value{}
 826                 if err := Unmarshal(b[:x], m); err != nil {
 827                         return nil, err
 828                 }
 829                 slice := f.getSlice(reflect.PtrTo(sub.typ))
 830                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
 831                 slice.Set(newSlice)
 832                 return b[x:], nil
 833         }
 834 }
 835
 836 func makeStdUInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 837         return func(b []byte, f pointer, w int) ([]byte, error) {
 838                 if w != WireBytes {
 839                         return nil, errInternalBadWireType
 840                 }
 841                 x, n := decodeVarint(b)
 842                 if n == 0 {
 843                         return nil, io.ErrUnexpectedEOF
 844                 }
 845                 b = b[n:]
 846                 if x > uint64(len(b)) {
 847                         return nil, io.ErrUnexpectedEOF
 848                 }
 849                 m := &uint64Value{}
 850                 if err := Unmarshal(b[:x], m); err != nil {
 851                         return nil, err
 852                 }
 853                 slice := f.getSlice(sub.typ)
 854                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
 855                 slice.Set(newSlice)
 856                 return b[x:], nil
 857         }
 858 }
 859
 860 func makeStdInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
 861         return func(ptr pointer, tagsize int) int {
 862                         t := ptr.asPointerTo(u.typ).Interface().(*int32)
 863                         v := &int32Value{*t}
 864                         siz := Size(v)
 865                         return tagsize + SizeVarint(uint64(siz)) + siz
 866                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 867                         t := ptr.asPointerTo(u.typ).Interface().(*int32)
 868                         v := &int32Value{*t}
 869                         buf, err := Marshal(v)
 870                         if err != nil {
 871                                 return nil, err
 872                         }
 873                         b = appendVarint(b, wiretag)
 874                         b = appendVarint(b, uint64(len(buf)))
 875                         b = append(b, buf...)
 876                         return b, nil
 877                 }
 878 }
 879
 880 func makeStdInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
 881         return func(ptr pointer, tagsize int) int {
 882                         if ptr.isNil() {
 883                                 return 0
 884                         }
 885                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
 886                         v := &int32Value{*t}
 887                         siz := Size(v)
 888                         return tagsize + SizeVarint(uint64(siz)) + siz
 889                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 890                         if ptr.isNil() {
 891                                 return b, nil
 892                         }
 893                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
 894                         v := &int32Value{*t}
 895                         buf, err := Marshal(v)
 896                         if err != nil {
 897                                 return nil, err
 898                         }
 899                         b = appendVarint(b, wiretag)
 900                         b = appendVarint(b, uint64(len(buf)))
 901                         b = append(b, buf...)
 902                         return b, nil
 903                 }
 904 }
 905
 906 func makeStdInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 907         return func(ptr pointer, tagsize int) int {
 908                         s := ptr.getSlice(u.typ)
 909                         n := 0
 910                         for i := 0; i < s.Len(); i++ {
 911                                 elem := s.Index(i)
 912                                 t := elem.Interface().(int32)
 913                                 v := &int32Value{t}
 914                                 siz := Size(v)
 915                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 916                         }
 917                         return n
 918                 },
 919                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 920                         s := ptr.getSlice(u.typ)
 921                         for i := 0; i < s.Len(); i++ {
 922                                 elem := s.Index(i)
 923                                 t := elem.Interface().(int32)
 924                                 v := &int32Value{t}
 925                                 siz := Size(v)
 926                                 buf, err := Marshal(v)
 927                                 if err != nil {
 928                                         return nil, err
 929                                 }
 930                                 b = appendVarint(b, wiretag)
 931                                 b = appendVarint(b, uint64(siz))
 932                                 b = append(b, buf...)
 933                         }
 934
 935                         return b, nil
 936                 }
 937 }
 938
 939 func makeStdInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
 940         return func(ptr pointer, tagsize int) int {
 941                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 942                         n := 0
 943                         for i := 0; i < s.Len(); i++ {
 944                                 elem := s.Index(i)
 945                                 t := elem.Interface().(*int32)
 946                                 v := &int32Value{*t}
 947                                 siz := Size(v)
 948                                 n += siz + SizeVarint(uint64(siz)) + tagsize
 949                         }
 950                         return n
 951                 },
 952                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
 953                         s := ptr.getSlice(reflect.PtrTo(u.typ))
 954                         for i := 0; i < s.Len(); i++ {
 955                                 elem := s.Index(i)
 956                                 t := elem.Interface().(*int32)
 957                                 v := &int32Value{*t}
 958                                 siz := Size(v)
 959                                 buf, err := Marshal(v)
 960                                 if err != nil {
 961                                         return nil, err
 962                                 }
 963                                 b = appendVarint(b, wiretag)
 964                                 b = appendVarint(b, uint64(siz))
 965                                 b = append(b, buf...)
 966                         }
 967
 968                         return b, nil
 969                 }
 970 }
 971
 972 func makeStdInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 973         return func(b []byte, f pointer, w int) ([]byte, error) {
 974                 if w != WireBytes {
 975                         return nil, errInternalBadWireType
 976                 }
 977                 x, n := decodeVarint(b)
 978                 if n == 0 {
 979                         return nil, io.ErrUnexpectedEOF
 980                 }
 981                 b = b[n:]
 982                 if x > uint64(len(b)) {
 983                         return nil, io.ErrUnexpectedEOF
 984                 }
 985                 m := &int32Value{}
 986                 if err := Unmarshal(b[:x], m); err != nil {
 987                         return nil, err
 988                 }
 989                 s := f.asPointerTo(sub.typ).Elem()
 990                 s.Set(reflect.ValueOf(m.Value))
 991                 return b[x:], nil
 992         }
 993 }
 994
 995 func makeStdInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
 996         return func(b []byte, f pointer, w int) ([]byte, error) {
 997                 if w != WireBytes {
 998                         return nil, errInternalBadWireType
 999                 }
1000                 x, n := decodeVarint(b)
1001                 if n == 0 {
1002                         return nil, io.ErrUnexpectedEOF
1003                 }
1004                 b = b[n:]
1005                 if x > uint64(len(b)) {
1006                         return nil, io.ErrUnexpectedEOF
1007                 }
1008                 m := &int32Value{}
1009                 if err := Unmarshal(b[:x], m); err != nil {
1010                         return nil, err
1011                 }
1012                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1013                 s.Set(reflect.ValueOf(&m.Value))
1014                 return b[x:], nil
1015         }
1016 }
1017
1018 func makeStdInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1019         return func(b []byte, f pointer, w int) ([]byte, error) {
1020                 if w != WireBytes {
1021                         return nil, errInternalBadWireType
1022                 }
1023                 x, n := decodeVarint(b)
1024                 if n == 0 {
1025                         return nil, io.ErrUnexpectedEOF
1026                 }
1027                 b = b[n:]
1028                 if x > uint64(len(b)) {
1029                         return nil, io.ErrUnexpectedEOF
1030                 }
1031                 m := &int32Value{}
1032                 if err := Unmarshal(b[:x], m); err != nil {
1033                         return nil, err
1034                 }
1035                 slice := f.getSlice(reflect.PtrTo(sub.typ))
1036                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1037                 slice.Set(newSlice)
1038                 return b[x:], nil
1039         }
1040 }
1041
1042 func makeStdInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1043         return func(b []byte, f pointer, w int) ([]byte, error) {
1044                 if w != WireBytes {
1045                         return nil, errInternalBadWireType
1046                 }
1047                 x, n := decodeVarint(b)
1048                 if n == 0 {
1049                         return nil, io.ErrUnexpectedEOF
1050                 }
1051                 b = b[n:]
1052                 if x > uint64(len(b)) {
1053                         return nil, io.ErrUnexpectedEOF
1054                 }
1055                 m := &int32Value{}
1056                 if err := Unmarshal(b[:x], m); err != nil {
1057                         return nil, err
1058                 }
1059                 slice := f.getSlice(sub.typ)
1060                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1061                 slice.Set(newSlice)
1062                 return b[x:], nil
1063         }
1064 }
1065
1066 func makeStdUInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1067         return func(ptr pointer, tagsize int) int {
1068                         t := ptr.asPointerTo(u.typ).Interface().(*uint32)
1069                         v := &uint32Value{*t}
1070                         siz := Size(v)
1071                         return tagsize + SizeVarint(uint64(siz)) + siz
1072                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1073                         t := ptr.asPointerTo(u.typ).Interface().(*uint32)
1074                         v := &uint32Value{*t}
1075                         buf, err := Marshal(v)
1076                         if err != nil {
1077                                 return nil, err
1078                         }
1079                         b = appendVarint(b, wiretag)
1080                         b = appendVarint(b, uint64(len(buf)))
1081                         b = append(b, buf...)
1082                         return b, nil
1083                 }
1084 }
1085
1086 func makeStdUInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1087         return func(ptr pointer, tagsize int) int {
1088                         if ptr.isNil() {
1089                                 return 0
1090                         }
1091                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
1092                         v := &uint32Value{*t}
1093                         siz := Size(v)
1094                         return tagsize + SizeVarint(uint64(siz)) + siz
1095                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1096                         if ptr.isNil() {
1097                                 return b, nil
1098                         }
1099                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
1100                         v := &uint32Value{*t}
1101                         buf, err := Marshal(v)
1102                         if err != nil {
1103                                 return nil, err
1104                         }
1105                         b = appendVarint(b, wiretag)
1106                         b = appendVarint(b, uint64(len(buf)))
1107                         b = append(b, buf...)
1108                         return b, nil
1109                 }
1110 }
1111
1112 func makeStdUInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1113         return func(ptr pointer, tagsize int) int {
1114                         s := ptr.getSlice(u.typ)
1115                         n := 0
1116                         for i := 0; i < s.Len(); i++ {
1117                                 elem := s.Index(i)
1118                                 t := elem.Interface().(uint32)
1119                                 v := &uint32Value{t}
1120                                 siz := Size(v)
1121                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1122                         }
1123                         return n
1124                 },
1125                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1126                         s := ptr.getSlice(u.typ)
1127                         for i := 0; i < s.Len(); i++ {
1128                                 elem := s.Index(i)
1129                                 t := elem.Interface().(uint32)
1130                                 v := &uint32Value{t}
1131                                 siz := Size(v)
1132                                 buf, err := Marshal(v)
1133                                 if err != nil {
1134                                         return nil, err
1135                                 }
1136                                 b = appendVarint(b, wiretag)
1137                                 b = appendVarint(b, uint64(siz))
1138                                 b = append(b, buf...)
1139                         }
1140
1141                         return b, nil
1142                 }
1143 }
1144
1145 func makeStdUInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1146         return func(ptr pointer, tagsize int) int {
1147                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1148                         n := 0
1149                         for i := 0; i < s.Len(); i++ {
1150                                 elem := s.Index(i)
1151                                 t := elem.Interface().(*uint32)
1152                                 v := &uint32Value{*t}
1153                                 siz := Size(v)
1154                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1155                         }
1156                         return n
1157                 },
1158                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1159                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1160                         for i := 0; i < s.Len(); i++ {
1161                                 elem := s.Index(i)
1162                                 t := elem.Interface().(*uint32)
1163                                 v := &uint32Value{*t}
1164                                 siz := Size(v)
1165                                 buf, err := Marshal(v)
1166                                 if err != nil {
1167                                         return nil, err
1168                                 }
1169                                 b = appendVarint(b, wiretag)
1170                                 b = appendVarint(b, uint64(siz))
1171                                 b = append(b, buf...)
1172                         }
1173
1174                         return b, nil
1175                 }
1176 }
1177
1178 func makeStdUInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1179         return func(b []byte, f pointer, w int) ([]byte, error) {
1180                 if w != WireBytes {
1181                         return nil, errInternalBadWireType
1182                 }
1183                 x, n := decodeVarint(b)
1184                 if n == 0 {
1185                         return nil, io.ErrUnexpectedEOF
1186                 }
1187                 b = b[n:]
1188                 if x > uint64(len(b)) {
1189                         return nil, io.ErrUnexpectedEOF
1190                 }
1191                 m := &uint32Value{}
1192                 if err := Unmarshal(b[:x], m); err != nil {
1193                         return nil, err
1194                 }
1195                 s := f.asPointerTo(sub.typ).Elem()
1196                 s.Set(reflect.ValueOf(m.Value))
1197                 return b[x:], nil
1198         }
1199 }
1200
1201 func makeStdUInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1202         return func(b []byte, f pointer, w int) ([]byte, error) {
1203                 if w != WireBytes {
1204                         return nil, errInternalBadWireType
1205                 }
1206                 x, n := decodeVarint(b)
1207                 if n == 0 {
1208                         return nil, io.ErrUnexpectedEOF
1209                 }
1210                 b = b[n:]
1211                 if x > uint64(len(b)) {
1212                         return nil, io.ErrUnexpectedEOF
1213                 }
1214                 m := &uint32Value{}
1215                 if err := Unmarshal(b[:x], m); err != nil {
1216                         return nil, err
1217                 }
1218                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1219                 s.Set(reflect.ValueOf(&m.Value))
1220                 return b[x:], nil
1221         }
1222 }
1223
1224 func makeStdUInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1225         return func(b []byte, f pointer, w int) ([]byte, error) {
1226                 if w != WireBytes {
1227                         return nil, errInternalBadWireType
1228                 }
1229                 x, n := decodeVarint(b)
1230                 if n == 0 {
1231                         return nil, io.ErrUnexpectedEOF
1232                 }
1233                 b = b[n:]
1234                 if x > uint64(len(b)) {
1235                         return nil, io.ErrUnexpectedEOF
1236                 }
1237                 m := &uint32Value{}
1238                 if err := Unmarshal(b[:x], m); err != nil {
1239                         return nil, err
1240                 }
1241                 slice := f.getSlice(reflect.PtrTo(sub.typ))
1242                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1243                 slice.Set(newSlice)
1244                 return b[x:], nil
1245         }
1246 }
1247
1248 func makeStdUInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1249         return func(b []byte, f pointer, w int) ([]byte, error) {
1250                 if w != WireBytes {
1251                         return nil, errInternalBadWireType
1252                 }
1253                 x, n := decodeVarint(b)
1254                 if n == 0 {
1255                         return nil, io.ErrUnexpectedEOF
1256                 }
1257                 b = b[n:]
1258                 if x > uint64(len(b)) {
1259                         return nil, io.ErrUnexpectedEOF
1260                 }
1261                 m := &uint32Value{}
1262                 if err := Unmarshal(b[:x], m); err != nil {
1263                         return nil, err
1264                 }
1265                 slice := f.getSlice(sub.typ)
1266                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1267                 slice.Set(newSlice)
1268                 return b[x:], nil
1269         }
1270 }
1271
1272 func makeStdBoolValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1273         return func(ptr pointer, tagsize int) int {
1274                         t := ptr.asPointerTo(u.typ).Interface().(*bool)
1275                         v := &boolValue{*t}
1276                         siz := Size(v)
1277                         return tagsize + SizeVarint(uint64(siz)) + siz
1278                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1279                         t := ptr.asPointerTo(u.typ).Interface().(*bool)
1280                         v := &boolValue{*t}
1281                         buf, err := Marshal(v)
1282                         if err != nil {
1283                                 return nil, err
1284                         }
1285                         b = appendVarint(b, wiretag)
1286                         b = appendVarint(b, uint64(len(buf)))
1287                         b = append(b, buf...)
1288                         return b, nil
1289                 }
1290 }
1291
1292 func makeStdBoolValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1293         return func(ptr pointer, tagsize int) int {
1294                         if ptr.isNil() {
1295                                 return 0
1296                         }
1297                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
1298                         v := &boolValue{*t}
1299                         siz := Size(v)
1300                         return tagsize + SizeVarint(uint64(siz)) + siz
1301                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1302                         if ptr.isNil() {
1303                                 return b, nil
1304                         }
1305                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
1306                         v := &boolValue{*t}
1307                         buf, err := Marshal(v)
1308                         if err != nil {
1309                                 return nil, err
1310                         }
1311                         b = appendVarint(b, wiretag)
1312                         b = appendVarint(b, uint64(len(buf)))
1313                         b = append(b, buf...)
1314                         return b, nil
1315                 }
1316 }
1317
1318 func makeStdBoolValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1319         return func(ptr pointer, tagsize int) int {
1320                         s := ptr.getSlice(u.typ)
1321                         n := 0
1322                         for i := 0; i < s.Len(); i++ {
1323                                 elem := s.Index(i)
1324                                 t := elem.Interface().(bool)
1325                                 v := &boolValue{t}
1326                                 siz := Size(v)
1327                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1328                         }
1329                         return n
1330                 },
1331                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1332                         s := ptr.getSlice(u.typ)
1333                         for i := 0; i < s.Len(); i++ {
1334                                 elem := s.Index(i)
1335                                 t := elem.Interface().(bool)
1336                                 v := &boolValue{t}
1337                                 siz := Size(v)
1338                                 buf, err := Marshal(v)
1339                                 if err != nil {
1340                                         return nil, err
1341                                 }
1342                                 b = appendVarint(b, wiretag)
1343                                 b = appendVarint(b, uint64(siz))
1344                                 b = append(b, buf...)
1345                         }
1346
1347                         return b, nil
1348                 }
1349 }
1350
1351 func makeStdBoolValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1352         return func(ptr pointer, tagsize int) int {
1353                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1354                         n := 0
1355                         for i := 0; i < s.Len(); i++ {
1356                                 elem := s.Index(i)
1357                                 t := elem.Interface().(*bool)
1358                                 v := &boolValue{*t}
1359                                 siz := Size(v)
1360                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1361                         }
1362                         return n
1363                 },
1364                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1365                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1366                         for i := 0; i < s.Len(); i++ {
1367                                 elem := s.Index(i)
1368                                 t := elem.Interface().(*bool)
1369                                 v := &boolValue{*t}
1370                                 siz := Size(v)
1371                                 buf, err := Marshal(v)
1372                                 if err != nil {
1373                                         return nil, err
1374                                 }
1375                                 b = appendVarint(b, wiretag)
1376                                 b = appendVarint(b, uint64(siz))
1377                                 b = append(b, buf...)
1378                         }
1379
1380                         return b, nil
1381                 }
1382 }
1383
1384 func makeStdBoolValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1385         return func(b []byte, f pointer, w int) ([]byte, error) {
1386                 if w != WireBytes {
1387                         return nil, errInternalBadWireType
1388                 }
1389                 x, n := decodeVarint(b)
1390                 if n == 0 {
1391                         return nil, io.ErrUnexpectedEOF
1392                 }
1393                 b = b[n:]
1394                 if x > uint64(len(b)) {
1395                         return nil, io.ErrUnexpectedEOF
1396                 }
1397                 m := &boolValue{}
1398                 if err := Unmarshal(b[:x], m); err != nil {
1399                         return nil, err
1400                 }
1401                 s := f.asPointerTo(sub.typ).Elem()
1402                 s.Set(reflect.ValueOf(m.Value))
1403                 return b[x:], nil
1404         }
1405 }
1406
1407 func makeStdBoolValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1408         return func(b []byte, f pointer, w int) ([]byte, error) {
1409                 if w != WireBytes {
1410                         return nil, errInternalBadWireType
1411                 }
1412                 x, n := decodeVarint(b)
1413                 if n == 0 {
1414                         return nil, io.ErrUnexpectedEOF
1415                 }
1416                 b = b[n:]
1417                 if x > uint64(len(b)) {
1418                         return nil, io.ErrUnexpectedEOF
1419                 }
1420                 m := &boolValue{}
1421                 if err := Unmarshal(b[:x], m); err != nil {
1422                         return nil, err
1423                 }
1424                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1425                 s.Set(reflect.ValueOf(&m.Value))
1426                 return b[x:], nil
1427         }
1428 }
1429
1430 func makeStdBoolValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1431         return func(b []byte, f pointer, w int) ([]byte, error) {
1432                 if w != WireBytes {
1433                         return nil, errInternalBadWireType
1434                 }
1435                 x, n := decodeVarint(b)
1436                 if n == 0 {
1437                         return nil, io.ErrUnexpectedEOF
1438                 }
1439                 b = b[n:]
1440                 if x > uint64(len(b)) {
1441                         return nil, io.ErrUnexpectedEOF
1442                 }
1443                 m := &boolValue{}
1444                 if err := Unmarshal(b[:x], m); err != nil {
1445                         return nil, err
1446                 }
1447                 slice := f.getSlice(reflect.PtrTo(sub.typ))
1448                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1449                 slice.Set(newSlice)
1450                 return b[x:], nil
1451         }
1452 }
1453
1454 func makeStdBoolValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1455         return func(b []byte, f pointer, w int) ([]byte, error) {
1456                 if w != WireBytes {
1457                         return nil, errInternalBadWireType
1458                 }
1459                 x, n := decodeVarint(b)
1460                 if n == 0 {
1461                         return nil, io.ErrUnexpectedEOF
1462                 }
1463                 b = b[n:]
1464                 if x > uint64(len(b)) {
1465                         return nil, io.ErrUnexpectedEOF
1466                 }
1467                 m := &boolValue{}
1468                 if err := Unmarshal(b[:x], m); err != nil {
1469                         return nil, err
1470                 }
1471                 slice := f.getSlice(sub.typ)
1472                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1473                 slice.Set(newSlice)
1474                 return b[x:], nil
1475         }
1476 }
1477
1478 func makeStdStringValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1479         return func(ptr pointer, tagsize int) int {
1480                         t := ptr.asPointerTo(u.typ).Interface().(*string)
1481                         v := &stringValue{*t}
1482                         siz := Size(v)
1483                         return tagsize + SizeVarint(uint64(siz)) + siz
1484                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1485                         t := ptr.asPointerTo(u.typ).Interface().(*string)
1486                         v := &stringValue{*t}
1487                         buf, err := Marshal(v)
1488                         if err != nil {
1489                                 return nil, err
1490                         }
1491                         b = appendVarint(b, wiretag)
1492                         b = appendVarint(b, uint64(len(buf)))
1493                         b = append(b, buf...)
1494                         return b, nil
1495                 }
1496 }
1497
1498 func makeStdStringValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1499         return func(ptr pointer, tagsize int) int {
1500                         if ptr.isNil() {
1501                                 return 0
1502                         }
1503                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
1504                         v := &stringValue{*t}
1505                         siz := Size(v)
1506                         return tagsize + SizeVarint(uint64(siz)) + siz
1507                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1508                         if ptr.isNil() {
1509                                 return b, nil
1510                         }
1511                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
1512                         v := &stringValue{*t}
1513                         buf, err := Marshal(v)
1514                         if err != nil {
1515                                 return nil, err
1516                         }
1517                         b = appendVarint(b, wiretag)
1518                         b = appendVarint(b, uint64(len(buf)))
1519                         b = append(b, buf...)
1520                         return b, nil
1521                 }
1522 }
1523
1524 func makeStdStringValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1525         return func(ptr pointer, tagsize int) int {
1526                         s := ptr.getSlice(u.typ)
1527                         n := 0
1528                         for i := 0; i < s.Len(); i++ {
1529                                 elem := s.Index(i)
1530                                 t := elem.Interface().(string)
1531                                 v := &stringValue{t}
1532                                 siz := Size(v)
1533                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1534                         }
1535                         return n
1536                 },
1537                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1538                         s := ptr.getSlice(u.typ)
1539                         for i := 0; i < s.Len(); i++ {
1540                                 elem := s.Index(i)
1541                                 t := elem.Interface().(string)
1542                                 v := &stringValue{t}
1543                                 siz := Size(v)
1544                                 buf, err := Marshal(v)
1545                                 if err != nil {
1546                                         return nil, err
1547                                 }
1548                                 b = appendVarint(b, wiretag)
1549                                 b = appendVarint(b, uint64(siz))
1550                                 b = append(b, buf...)
1551                         }
1552
1553                         return b, nil
1554                 }
1555 }
1556
1557 func makeStdStringValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1558         return func(ptr pointer, tagsize int) int {
1559                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1560                         n := 0
1561                         for i := 0; i < s.Len(); i++ {
1562                                 elem := s.Index(i)
1563                                 t := elem.Interface().(*string)
1564                                 v := &stringValue{*t}
1565                                 siz := Size(v)
1566                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1567                         }
1568                         return n
1569                 },
1570                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1571                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1572                         for i := 0; i < s.Len(); i++ {
1573                                 elem := s.Index(i)
1574                                 t := elem.Interface().(*string)
1575                                 v := &stringValue{*t}
1576                                 siz := Size(v)
1577                                 buf, err := Marshal(v)
1578                                 if err != nil {
1579                                         return nil, err
1580                                 }
1581                                 b = appendVarint(b, wiretag)
1582                                 b = appendVarint(b, uint64(siz))
1583                                 b = append(b, buf...)
1584                         }
1585
1586                         return b, nil
1587                 }
1588 }
1589
1590 func makeStdStringValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1591         return func(b []byte, f pointer, w int) ([]byte, error) {
1592                 if w != WireBytes {
1593                         return nil, errInternalBadWireType
1594                 }
1595                 x, n := decodeVarint(b)
1596                 if n == 0 {
1597                         return nil, io.ErrUnexpectedEOF
1598                 }
1599                 b = b[n:]
1600                 if x > uint64(len(b)) {
1601                         return nil, io.ErrUnexpectedEOF
1602                 }
1603                 m := &stringValue{}
1604                 if err := Unmarshal(b[:x], m); err != nil {
1605                         return nil, err
1606                 }
1607                 s := f.asPointerTo(sub.typ).Elem()
1608                 s.Set(reflect.ValueOf(m.Value))
1609                 return b[x:], nil
1610         }
1611 }
1612
1613 func makeStdStringValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1614         return func(b []byte, f pointer, w int) ([]byte, error) {
1615                 if w != WireBytes {
1616                         return nil, errInternalBadWireType
1617                 }
1618                 x, n := decodeVarint(b)
1619                 if n == 0 {
1620                         return nil, io.ErrUnexpectedEOF
1621                 }
1622                 b = b[n:]
1623                 if x > uint64(len(b)) {
1624                         return nil, io.ErrUnexpectedEOF
1625                 }
1626                 m := &stringValue{}
1627                 if err := Unmarshal(b[:x], m); err != nil {
1628                         return nil, err
1629                 }
1630                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1631                 s.Set(reflect.ValueOf(&m.Value))
1632                 return b[x:], nil
1633         }
1634 }
1635
1636 func makeStdStringValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1637         return func(b []byte, f pointer, w int) ([]byte, error) {
1638                 if w != WireBytes {
1639                         return nil, errInternalBadWireType
1640                 }
1641                 x, n := decodeVarint(b)
1642                 if n == 0 {
1643                         return nil, io.ErrUnexpectedEOF
1644                 }
1645                 b = b[n:]
1646                 if x > uint64(len(b)) {
1647                         return nil, io.ErrUnexpectedEOF
1648                 }
1649                 m := &stringValue{}
1650                 if err := Unmarshal(b[:x], m); err != nil {
1651                         return nil, err
1652                 }
1653                 slice := f.getSlice(reflect.PtrTo(sub.typ))
1654                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1655                 slice.Set(newSlice)
1656                 return b[x:], nil
1657         }
1658 }
1659
1660 func makeStdStringValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1661         return func(b []byte, f pointer, w int) ([]byte, error) {
1662                 if w != WireBytes {
1663                         return nil, errInternalBadWireType
1664                 }
1665                 x, n := decodeVarint(b)
1666                 if n == 0 {
1667                         return nil, io.ErrUnexpectedEOF
1668                 }
1669                 b = b[n:]
1670                 if x > uint64(len(b)) {
1671                         return nil, io.ErrUnexpectedEOF
1672                 }
1673                 m := &stringValue{}
1674                 if err := Unmarshal(b[:x], m); err != nil {
1675                         return nil, err
1676                 }
1677                 slice := f.getSlice(sub.typ)
1678                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1679                 slice.Set(newSlice)
1680                 return b[x:], nil
1681         }
1682 }
1683
1684 func makeStdBytesValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1685         return func(ptr pointer, tagsize int) int {
1686                         t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
1687                         v := &bytesValue{*t}
1688                         siz := Size(v)
1689                         return tagsize + SizeVarint(uint64(siz)) + siz
1690                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1691                         t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
1692                         v := &bytesValue{*t}
1693                         buf, err := Marshal(v)
1694                         if err != nil {
1695                                 return nil, err
1696                         }
1697                         b = appendVarint(b, wiretag)
1698                         b = appendVarint(b, uint64(len(buf)))
1699                         b = append(b, buf...)
1700                         return b, nil
1701                 }
1702 }
1703
1704 func makeStdBytesValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1705         return func(ptr pointer, tagsize int) int {
1706                         if ptr.isNil() {
1707                                 return 0
1708                         }
1709                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
1710                         v := &bytesValue{*t}
1711                         siz := Size(v)
1712                         return tagsize + SizeVarint(uint64(siz)) + siz
1713                 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1714                         if ptr.isNil() {
1715                                 return b, nil
1716                         }
1717                         t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
1718                         v := &bytesValue{*t}
1719                         buf, err := Marshal(v)
1720                         if err != nil {
1721                                 return nil, err
1722                         }
1723                         b = appendVarint(b, wiretag)
1724                         b = appendVarint(b, uint64(len(buf)))
1725                         b = append(b, buf...)
1726                         return b, nil
1727                 }
1728 }
1729
1730 func makeStdBytesValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1731         return func(ptr pointer, tagsize int) int {
1732                         s := ptr.getSlice(u.typ)
1733                         n := 0
1734                         for i := 0; i < s.Len(); i++ {
1735                                 elem := s.Index(i)
1736                                 t := elem.Interface().([]byte)
1737                                 v := &bytesValue{t}
1738                                 siz := Size(v)
1739                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1740                         }
1741                         return n
1742                 },
1743                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1744                         s := ptr.getSlice(u.typ)
1745                         for i := 0; i < s.Len(); i++ {
1746                                 elem := s.Index(i)
1747                                 t := elem.Interface().([]byte)
1748                                 v := &bytesValue{t}
1749                                 siz := Size(v)
1750                                 buf, err := Marshal(v)
1751                                 if err != nil {
1752                                         return nil, err
1753                                 }
1754                                 b = appendVarint(b, wiretag)
1755                                 b = appendVarint(b, uint64(siz))
1756                                 b = append(b, buf...)
1757                         }
1758
1759                         return b, nil
1760                 }
1761 }
1762
1763 func makeStdBytesValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1764         return func(ptr pointer, tagsize int) int {
1765                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1766                         n := 0
1767                         for i := 0; i < s.Len(); i++ {
1768                                 elem := s.Index(i)
1769                                 t := elem.Interface().(*[]byte)
1770                                 v := &bytesValue{*t}
1771                                 siz := Size(v)
1772                                 n += siz + SizeVarint(uint64(siz)) + tagsize
1773                         }
1774                         return n
1775                 },
1776                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1777                         s := ptr.getSlice(reflect.PtrTo(u.typ))
1778                         for i := 0; i < s.Len(); i++ {
1779                                 elem := s.Index(i)
1780                                 t := elem.Interface().(*[]byte)
1781                                 v := &bytesValue{*t}
1782                                 siz := Size(v)
1783                                 buf, err := Marshal(v)
1784                                 if err != nil {
1785                                         return nil, err
1786                                 }
1787                                 b = appendVarint(b, wiretag)
1788                                 b = appendVarint(b, uint64(siz))
1789                                 b = append(b, buf...)
1790                         }
1791
1792                         return b, nil
1793                 }
1794 }
1795
1796 func makeStdBytesValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1797         return func(b []byte, f pointer, w int) ([]byte, error) {
1798                 if w != WireBytes {
1799                         return nil, errInternalBadWireType
1800                 }
1801                 x, n := decodeVarint(b)
1802                 if n == 0 {
1803                         return nil, io.ErrUnexpectedEOF
1804                 }
1805                 b = b[n:]
1806                 if x > uint64(len(b)) {
1807                         return nil, io.ErrUnexpectedEOF
1808                 }
1809                 m := &bytesValue{}
1810                 if err := Unmarshal(b[:x], m); err != nil {
1811                         return nil, err
1812                 }
1813                 s := f.asPointerTo(sub.typ).Elem()
1814                 s.Set(reflect.ValueOf(m.Value))
1815                 return b[x:], nil
1816         }
1817 }
1818
1819 func makeStdBytesValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1820         return func(b []byte, f pointer, w int) ([]byte, error) {
1821                 if w != WireBytes {
1822                         return nil, errInternalBadWireType
1823                 }
1824                 x, n := decodeVarint(b)
1825                 if n == 0 {
1826                         return nil, io.ErrUnexpectedEOF
1827                 }
1828                 b = b[n:]
1829                 if x > uint64(len(b)) {
1830                         return nil, io.ErrUnexpectedEOF
1831                 }
1832                 m := &bytesValue{}
1833                 if err := Unmarshal(b[:x], m); err != nil {
1834                         return nil, err
1835                 }
1836                 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1837                 s.Set(reflect.ValueOf(&m.Value))
1838                 return b[x:], nil
1839         }
1840 }
1841
1842 func makeStdBytesValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1843         return func(b []byte, f pointer, w int) ([]byte, error) {
1844                 if w != WireBytes {
1845                         return nil, errInternalBadWireType
1846                 }
1847                 x, n := decodeVarint(b)
1848                 if n == 0 {
1849                         return nil, io.ErrUnexpectedEOF
1850                 }
1851                 b = b[n:]
1852                 if x > uint64(len(b)) {
1853                         return nil, io.ErrUnexpectedEOF
1854                 }
1855                 m := &bytesValue{}
1856                 if err := Unmarshal(b[:x], m); err != nil {
1857                         return nil, err
1858                 }
1859                 slice := f.getSlice(reflect.PtrTo(sub.typ))
1860                 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1861                 slice.Set(newSlice)
1862                 return b[x:], nil
1863         }
1864 }
1865
1866 func makeStdBytesValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1867         return func(b []byte, f pointer, w int) ([]byte, error) {
1868                 if w != WireBytes {
1869                         return nil, errInternalBadWireType
1870                 }
1871                 x, n := decodeVarint(b)
1872                 if n == 0 {
1873                         return nil, io.ErrUnexpectedEOF
1874                 }
1875                 b = b[n:]
1876                 if x > uint64(len(b)) {
1877                         return nil, io.ErrUnexpectedEOF
1878                 }
1879                 m := &bytesValue{}
1880                 if err := Unmarshal(b[:x], m); err != nil {
1881                         return nil, err
1882                 }
1883                 slice := f.getSlice(sub.typ)
1884                 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1885                 slice.Set(newSlice)
1886                 return b[x:], nil
1887         }
1888 }