cmd/bpa-operator/vendor/github.com/gogo/protobuf/proto/table_marshal.go

   1 // Go support for Protocol Buffers - Google's data interchange format
   2 //
   3 // Copyright 2016 The Go Authors.  All rights reserved.
   4 // https://github.com/golang/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 //     * Neither the name of Google Inc. nor the names of its
  17 // contributors may be used to endorse or promote products derived from
  18 // this software without specific prior written permission.
  19 //
  20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31
  32 package proto
  33
  34 import (
  35         "errors"
  36         "fmt"
  37         "math"
  38         "reflect"
  39         "sort"
  40         "strconv"
  41         "strings"
  42         "sync"
  43         "sync/atomic"
  44         "unicode/utf8"
  45 )
  46
  47 // a sizer takes a pointer to a field and the size of its tag, computes the size of
  48 // the encoded data.
  49 type sizer func(pointer, int) int
  50
  51 // a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),
  52 // marshals the field to the end of the slice, returns the slice and error (if any).
  53 type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)
  54
  55 // marshalInfo is the information used for marshaling a message.
  56 type marshalInfo struct {
  57         typ          reflect.Type
  58         fields       []*marshalFieldInfo
  59         unrecognized field                      // offset of XXX_unrecognized
  60         extensions   field                      // offset of XXX_InternalExtensions
  61         v1extensions field                      // offset of XXX_extensions
  62         sizecache    field                      // offset of XXX_sizecache
  63         initialized  int32                      // 0 -- only typ is set, 1 -- fully initialized
  64         messageset   bool                       // uses message set wire format
  65         hasmarshaler bool                       // has custom marshaler
  66         sync.RWMutex                            // protect extElems map, also for initialization
  67         extElems     map[int32]*marshalElemInfo // info of extension elements
  68
  69         hassizer      bool // has custom sizer
  70         hasprotosizer bool // has custom protosizer
  71
  72         bytesExtensions field // offset of XXX_extensions where the field type is []byte
  73 }
  74
  75 // marshalFieldInfo is the information used for marshaling a field of a message.
  76 type marshalFieldInfo struct {
  77         field      field
  78         wiretag    uint64 // tag in wire format
  79         tagsize    int    // size of tag in wire format
  80         sizer      sizer
  81         marshaler  marshaler
  82         isPointer  bool
  83         required   bool                              // field is required
  84         name       string                            // name of the field, for error reporting
  85         oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements
  86 }
  87
  88 // marshalElemInfo is the information used for marshaling an extension or oneof element.
  89 type marshalElemInfo struct {
  90         wiretag   uint64 // tag in wire format
  91         tagsize   int    // size of tag in wire format
  92         sizer     sizer
  93         marshaler marshaler
  94         isptr     bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
  95 }
  96
  97 var (
  98         marshalInfoMap  = map[reflect.Type]*marshalInfo{}
  99         marshalInfoLock sync.Mutex
 100
 101         uint8SliceType = reflect.TypeOf(([]uint8)(nil)).Kind()
 102 )
 103
 104 // getMarshalInfo returns the information to marshal a given type of message.
 105 // The info it returns may not necessarily initialized.
 106 // t is the type of the message (NOT the pointer to it).
 107 func getMarshalInfo(t reflect.Type) *marshalInfo {
 108         marshalInfoLock.Lock()
 109         u, ok := marshalInfoMap[t]
 110         if !ok {
 111                 u = &marshalInfo{typ: t}
 112                 marshalInfoMap[t] = u
 113         }
 114         marshalInfoLock.Unlock()
 115         return u
 116 }
 117
 118 // Size is the entry point from generated code,
 119 // and should be ONLY called by generated code.
 120 // It computes the size of encoded data of msg.
 121 // a is a pointer to a place to store cached marshal info.
 122 func (a *InternalMessageInfo) Size(msg Message) int {
 123         u := getMessageMarshalInfo(msg, a)
 124         ptr := toPointer(&msg)
 125         if ptr.isNil() {
 126                 // We get here if msg is a typed nil ((*SomeMessage)(nil)),
 127                 // so it satisfies the interface, and msg == nil wouldn't
 128                 // catch it. We don't want crash in this case.
 129                 return 0
 130         }
 131         return u.size(ptr)
 132 }
 133
 134 // Marshal is the entry point from generated code,
 135 // and should be ONLY called by generated code.
 136 // It marshals msg to the end of b.
 137 // a is a pointer to a place to store cached marshal info.
 138 func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {
 139         u := getMessageMarshalInfo(msg, a)
 140         ptr := toPointer(&msg)
 141         if ptr.isNil() {
 142                 // We get here if msg is a typed nil ((*SomeMessage)(nil)),
 143                 // so it satisfies the interface, and msg == nil wouldn't
 144                 // catch it. We don't want crash in this case.
 145                 return b, ErrNil
 146         }
 147         return u.marshal(b, ptr, deterministic)
 148 }
 149
 150 func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {
 151         // u := a.marshal, but atomically.
 152         // We use an atomic here to ensure memory consistency.
 153         u := atomicLoadMarshalInfo(&a.marshal)
 154         if u == nil {
 155                 // Get marshal information from type of message.
 156                 t := reflect.ValueOf(msg).Type()
 157                 if t.Kind() != reflect.Ptr {
 158                         panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))
 159                 }
 160                 u = getMarshalInfo(t.Elem())
 161                 // Store it in the cache for later users.
 162                 // a.marshal = u, but atomically.
 163                 atomicStoreMarshalInfo(&a.marshal, u)
 164         }
 165         return u
 166 }
 167
 168 // size is the main function to compute the size of the encoded data of a message.
 169 // ptr is the pointer to the message.
 170 func (u *marshalInfo) size(ptr pointer) int {
 171         if atomic.LoadInt32(&u.initialized) == 0 {
 172                 u.computeMarshalInfo()
 173         }
 174
 175         // If the message can marshal itself, let it do it, for compatibility.
 176         // NOTE: This is not efficient.
 177         if u.hasmarshaler {
 178                 // Uses the message's Size method if available
 179                 if u.hassizer {
 180                         s := ptr.asPointerTo(u.typ).Interface().(Sizer)
 181                         return s.Size()
 182                 }
 183                 // Uses the message's ProtoSize method if available
 184                 if u.hasprotosizer {
 185                         s := ptr.asPointerTo(u.typ).Interface().(ProtoSizer)
 186                         return s.ProtoSize()
 187                 }
 188
 189                 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
 190                 b, _ := m.Marshal()
 191                 return len(b)
 192         }
 193
 194         n := 0
 195         for _, f := range u.fields {
 196                 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
 197                         // nil pointer always marshals to nothing
 198                         continue
 199                 }
 200                 n += f.sizer(ptr.offset(f.field), f.tagsize)
 201         }
 202         if u.extensions.IsValid() {
 203                 e := ptr.offset(u.extensions).toExtensions()
 204                 if u.messageset {
 205                         n += u.sizeMessageSet(e)
 206                 } else {
 207                         n += u.sizeExtensions(e)
 208                 }
 209         }
 210         if u.v1extensions.IsValid() {
 211                 m := *ptr.offset(u.v1extensions).toOldExtensions()
 212                 n += u.sizeV1Extensions(m)
 213         }
 214         if u.bytesExtensions.IsValid() {
 215                 s := *ptr.offset(u.bytesExtensions).toBytes()
 216                 n += len(s)
 217         }
 218         if u.unrecognized.IsValid() {
 219                 s := *ptr.offset(u.unrecognized).toBytes()
 220                 n += len(s)
 221         }
 222
 223         // cache the result for use in marshal
 224         if u.sizecache.IsValid() {
 225                 atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
 226         }
 227         return n
 228 }
 229
 230 // cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),
 231 // fall back to compute the size.
 232 func (u *marshalInfo) cachedsize(ptr pointer) int {
 233         if u.sizecache.IsValid() {
 234                 return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))
 235         }
 236         return u.size(ptr)
 237 }
 238
 239 // marshal is the main function to marshal a message. It takes a byte slice and appends
 240 // the encoded data to the end of the slice, returns the slice and error (if any).
 241 // ptr is the pointer to the message.
 242 // If deterministic is true, map is marshaled in deterministic order.
 243 func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {
 244         if atomic.LoadInt32(&u.initialized) == 0 {
 245                 u.computeMarshalInfo()
 246         }
 247
 248         // If the message can marshal itself, let it do it, for compatibility.
 249         // NOTE: This is not efficient.
 250         if u.hasmarshaler {
 251                 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
 252                 b1, err := m.Marshal()
 253                 b = append(b, b1...)
 254                 return b, err
 255         }
 256
 257         var err, errLater error
 258         // The old marshaler encodes extensions at beginning.
 259         if u.extensions.IsValid() {
 260                 e := ptr.offset(u.extensions).toExtensions()
 261                 if u.messageset {
 262                         b, err = u.appendMessageSet(b, e, deterministic)
 263                 } else {
 264                         b, err = u.appendExtensions(b, e, deterministic)
 265                 }
 266                 if err != nil {
 267                         return b, err
 268                 }
 269         }
 270         if u.v1extensions.IsValid() {
 271                 m := *ptr.offset(u.v1extensions).toOldExtensions()
 272                 b, err = u.appendV1Extensions(b, m, deterministic)
 273                 if err != nil {
 274                         return b, err
 275                 }
 276         }
 277         if u.bytesExtensions.IsValid() {
 278                 s := *ptr.offset(u.bytesExtensions).toBytes()
 279                 b = append(b, s...)
 280         }
 281         for _, f := range u.fields {
 282                 if f.required {
 283                         if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
 284                                 // Required field is not set.
 285                                 // We record the error but keep going, to give a complete marshaling.
 286                                 if errLater == nil {
 287                                         errLater = &RequiredNotSetError{f.name}
 288                                 }
 289                                 continue
 290                         }
 291                 }
 292                 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
 293                         // nil pointer always marshals to nothing
 294                         continue
 295                 }
 296                 b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
 297                 if err != nil {
 298                         if err1, ok := err.(*RequiredNotSetError); ok {
 299                                 // Required field in submessage is not set.
 300                                 // We record the error but keep going, to give a complete marshaling.
 301                                 if errLater == nil {
 302                                         errLater = &RequiredNotSetError{f.name + "." + err1.field}
 303                                 }
 304                                 continue
 305                         }
 306                         if err == errRepeatedHasNil {
 307                                 err = errors.New("proto: repeated field " + f.name + " has nil element")
 308                         }
 309                         if err == errInvalidUTF8 {
 310                                 if errLater == nil {
 311                                         fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
 312                                         errLater = &invalidUTF8Error{fullName}
 313                                 }
 314                                 continue
 315                         }
 316                         return b, err
 317                 }
 318         }
 319         if u.unrecognized.IsValid() {
 320                 s := *ptr.offset(u.unrecognized).toBytes()
 321                 b = append(b, s...)
 322         }
 323         return b, errLater
 324 }
 325
 326 // computeMarshalInfo initializes the marshal info.
 327 func (u *marshalInfo) computeMarshalInfo() {
 328         u.Lock()
 329         defer u.Unlock()
 330         if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
 331                 return
 332         }
 333
 334         t := u.typ
 335         u.unrecognized = invalidField
 336         u.extensions = invalidField
 337         u.v1extensions = invalidField
 338         u.bytesExtensions = invalidField
 339         u.sizecache = invalidField
 340         isOneofMessage := false
 341
 342         if reflect.PtrTo(t).Implements(sizerType) {
 343                 u.hassizer = true
 344         }
 345         if reflect.PtrTo(t).Implements(protosizerType) {
 346                 u.hasprotosizer = true
 347         }
 348         // If the message can marshal itself, let it do it, for compatibility.
 349         // NOTE: This is not efficient.
 350         if reflect.PtrTo(t).Implements(marshalerType) {
 351                 u.hasmarshaler = true
 352                 atomic.StoreInt32(&u.initialized, 1)
 353                 return
 354         }
 355
 356         n := t.NumField()
 357
 358         // deal with XXX fields first
 359         for i := 0; i < t.NumField(); i++ {
 360                 f := t.Field(i)
 361                 if f.Tag.Get("protobuf_oneof") != "" {
 362                         isOneofMessage = true
 363                 }
 364                 if !strings.HasPrefix(f.Name, "XXX_") {
 365                         continue
 366                 }
 367                 switch f.Name {
 368                 case "XXX_sizecache":
 369                         u.sizecache = toField(&f)
 370                 case "XXX_unrecognized":
 371                         u.unrecognized = toField(&f)
 372                 case "XXX_InternalExtensions":
 373                         u.extensions = toField(&f)
 374                         u.messageset = f.Tag.Get("protobuf_messageset") == "1"
 375                 case "XXX_extensions":
 376                         if f.Type.Kind() == reflect.Map {
 377                                 u.v1extensions = toField(&f)
 378                         } else {
 379                                 u.bytesExtensions = toField(&f)
 380                         }
 381                 case "XXX_NoUnkeyedLiteral":
 382                         // nothing to do
 383                 default:
 384                         panic("unknown XXX field: " + f.Name)
 385                 }
 386                 n--
 387         }
 388
 389         // get oneof implementers
 390         var oneofImplementers []interface{}
 391         // gogo: isOneofMessage is needed for embedded oneof messages, without a marshaler and unmarshaler
 392         if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok && isOneofMessage {
 393                 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
 394         }
 395
 396         // normal fields
 397         fields := make([]marshalFieldInfo, n) // batch allocation
 398         u.fields = make([]*marshalFieldInfo, 0, n)
 399         for i, j := 0, 0; i < t.NumField(); i++ {
 400                 f := t.Field(i)
 401
 402                 if strings.HasPrefix(f.Name, "XXX_") {
 403                         continue
 404                 }
 405                 field := &fields[j]
 406                 j++
 407                 field.name = f.Name
 408                 u.fields = append(u.fields, field)
 409                 if f.Tag.Get("protobuf_oneof") != "" {
 410                         field.computeOneofFieldInfo(&f, oneofImplementers)
 411                         continue
 412                 }
 413                 if f.Tag.Get("protobuf") == "" {
 414                         // field has no tag (not in generated message), ignore it
 415                         u.fields = u.fields[:len(u.fields)-1]
 416                         j--
 417                         continue
 418                 }
 419                 field.computeMarshalFieldInfo(&f)
 420         }
 421
 422         // fields are marshaled in tag order on the wire.
 423         sort.Sort(byTag(u.fields))
 424
 425         atomic.StoreInt32(&u.initialized, 1)
 426 }
 427
 428 // helper for sorting fields by tag
 429 type byTag []*marshalFieldInfo
 430
 431 func (a byTag) Len() int           { return len(a) }
 432 func (a byTag) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 433 func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
 434
 435 // getExtElemInfo returns the information to marshal an extension element.
 436 // The info it returns is initialized.
 437 func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
 438         // get from cache first
 439         u.RLock()
 440         e, ok := u.extElems[desc.Field]
 441         u.RUnlock()
 442         if ok {
 443                 return e
 444         }
 445
 446         t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
 447         tags := strings.Split(desc.Tag, ",")
 448         tag, err := strconv.Atoi(tags[1])
 449         if err != nil {
 450                 panic("tag is not an integer")
 451         }
 452         wt := wiretype(tags[0])
 453         sizr, marshalr := typeMarshaler(t, tags, false, false)
 454         e = &marshalElemInfo{
 455                 wiretag:   uint64(tag)<<3 | wt,
 456                 tagsize:   SizeVarint(uint64(tag) << 3),
 457                 sizer:     sizr,
 458                 marshaler: marshalr,
 459                 isptr:     t.Kind() == reflect.Ptr,
 460         }
 461
 462         // update cache
 463         u.Lock()
 464         if u.extElems == nil {
 465                 u.extElems = make(map[int32]*marshalElemInfo)
 466         }
 467         u.extElems[desc.Field] = e
 468         u.Unlock()
 469         return e
 470 }
 471
 472 // computeMarshalFieldInfo fills up the information to marshal a field.
 473 func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
 474         // parse protobuf tag of the field.
 475         // tag has format of "bytes,49,opt,name=foo,def=hello!"
 476         tags := strings.Split(f.Tag.Get("protobuf"), ",")
 477         if tags[0] == "" {
 478                 return
 479         }
 480         tag, err := strconv.Atoi(tags[1])
 481         if err != nil {
 482                 panic("tag is not an integer")
 483         }
 484         wt := wiretype(tags[0])
 485         if tags[2] == "req" {
 486                 fi.required = true
 487         }
 488         fi.setTag(f, tag, wt)
 489         fi.setMarshaler(f, tags)
 490 }
 491
 492 func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
 493         fi.field = toField(f)
 494         fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
 495         fi.isPointer = true
 496         fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
 497         fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
 498
 499         ityp := f.Type // interface type
 500         for _, o := range oneofImplementers {
 501                 t := reflect.TypeOf(o)
 502                 if !t.Implements(ityp) {
 503                         continue
 504                 }
 505                 sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
 506                 tags := strings.Split(sf.Tag.Get("protobuf"), ",")
 507                 tag, err := strconv.Atoi(tags[1])
 508                 if err != nil {
 509                         panic("tag is not an integer")
 510                 }
 511                 wt := wiretype(tags[0])
 512                 sizr, marshalr := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
 513                 fi.oneofElems[t.Elem()] = &marshalElemInfo{
 514                         wiretag:   uint64(tag)<<3 | wt,
 515                         tagsize:   SizeVarint(uint64(tag) << 3),
 516                         sizer:     sizr,
 517                         marshaler: marshalr,
 518                 }
 519         }
 520 }
 521
 522 type oneofMessage interface {
 523         XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
 524 }
 525
 526 // wiretype returns the wire encoding of the type.
 527 func wiretype(encoding string) uint64 {
 528         switch encoding {
 529         case "fixed32":
 530                 return WireFixed32
 531         case "fixed64":
 532                 return WireFixed64
 533         case "varint", "zigzag32", "zigzag64":
 534                 return WireVarint
 535         case "bytes":
 536                 return WireBytes
 537         case "group":
 538                 return WireStartGroup
 539         }
 540         panic("unknown wire type " + encoding)
 541 }
 542
 543 // setTag fills up the tag (in wire format) and its size in the info of a field.
 544 func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
 545         fi.field = toField(f)
 546         fi.wiretag = uint64(tag)<<3 | wt
 547         fi.tagsize = SizeVarint(uint64(tag) << 3)
 548 }
 549
 550 // setMarshaler fills up the sizer and marshaler in the info of a field.
 551 func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
 552         switch f.Type.Kind() {
 553         case reflect.Map:
 554                 // map field
 555                 fi.isPointer = true
 556                 fi.sizer, fi.marshaler = makeMapMarshaler(f)
 557                 return
 558         case reflect.Ptr, reflect.Slice:
 559                 fi.isPointer = true
 560         }
 561         fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
 562 }
 563
 564 // typeMarshaler returns the sizer and marshaler of a given field.
 565 // t is the type of the field.
 566 // tags is the generated "protobuf" tag of the field.
 567 // If nozero is true, zero value is not marshaled to the wire.
 568 // If oneof is true, it is a oneof field.
 569 func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
 570         encoding := tags[0]
 571
 572         pointer := false
 573         slice := false
 574         if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
 575                 slice = true
 576                 t = t.Elem()
 577         }
 578         if t.Kind() == reflect.Ptr {
 579                 pointer = true
 580                 t = t.Elem()
 581         }
 582
 583         packed := false
 584         proto3 := false
 585         ctype := false
 586         isTime := false
 587         isDuration := false
 588         isWktPointer := false
 589         validateUTF8 := true
 590         for i := 2; i < len(tags); i++ {
 591                 if tags[i] == "packed" {
 592                         packed = true
 593                 }
 594                 if tags[i] == "proto3" {
 595                         proto3 = true
 596                 }
 597                 if strings.HasPrefix(tags[i], "customtype=") {
 598                         ctype = true
 599                 }
 600                 if tags[i] == "stdtime" {
 601                         isTime = true
 602                 }
 603                 if tags[i] == "stdduration" {
 604                         isDuration = true
 605                 }
 606                 if tags[i] == "wktptr" {
 607                         isWktPointer = true
 608                 }
 609         }
 610         validateUTF8 = validateUTF8 && proto3
 611         if !proto3 && !pointer && !slice {
 612                 nozero = false
 613         }
 614
 615         if ctype {
 616                 if reflect.PtrTo(t).Implements(customType) {
 617                         if slice {
 618                                 return makeMessageRefSliceMarshaler(getMarshalInfo(t))
 619                         }
 620                         if pointer {
 621                                 return makeCustomPtrMarshaler(getMarshalInfo(t))
 622                         }
 623                         return makeCustomMarshaler(getMarshalInfo(t))
 624                 } else {
 625                         panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
 626                 }
 627         }
 628
 629         if isTime {
 630                 if pointer {
 631                         if slice {
 632                                 return makeTimePtrSliceMarshaler(getMarshalInfo(t))
 633                         }
 634                         return makeTimePtrMarshaler(getMarshalInfo(t))
 635                 }
 636                 if slice {
 637                         return makeTimeSliceMarshaler(getMarshalInfo(t))
 638                 }
 639                 return makeTimeMarshaler(getMarshalInfo(t))
 640         }
 641
 642         if isDuration {
 643                 if pointer {
 644                         if slice {
 645                                 return makeDurationPtrSliceMarshaler(getMarshalInfo(t))
 646                         }
 647                         return makeDurationPtrMarshaler(getMarshalInfo(t))
 648                 }
 649                 if slice {
 650                         return makeDurationSliceMarshaler(getMarshalInfo(t))
 651                 }
 652                 return makeDurationMarshaler(getMarshalInfo(t))
 653         }
 654
 655         if isWktPointer {
 656                 switch t.Kind() {
 657                 case reflect.Float64:
 658                         if pointer {
 659                                 if slice {
 660                                         return makeStdDoubleValuePtrSliceMarshaler(getMarshalInfo(t))
 661                                 }
 662                                 return makeStdDoubleValuePtrMarshaler(getMarshalInfo(t))
 663                         }
 664                         if slice {
 665                                 return makeStdDoubleValueSliceMarshaler(getMarshalInfo(t))
 666                         }
 667                         return makeStdDoubleValueMarshaler(getMarshalInfo(t))
 668                 case reflect.Float32:
 669                         if pointer {
 670                                 if slice {
 671                                         return makeStdFloatValuePtrSliceMarshaler(getMarshalInfo(t))
 672                                 }
 673                                 return makeStdFloatValuePtrMarshaler(getMarshalInfo(t))
 674                         }
 675                         if slice {
 676                                 return makeStdFloatValueSliceMarshaler(getMarshalInfo(t))
 677                         }
 678                         return makeStdFloatValueMarshaler(getMarshalInfo(t))
 679                 case reflect.Int64:
 680                         if pointer {
 681                                 if slice {
 682                                         return makeStdInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
 683                                 }
 684                                 return makeStdInt64ValuePtrMarshaler(getMarshalInfo(t))
 685                         }
 686                         if slice {
 687                                 return makeStdInt64ValueSliceMarshaler(getMarshalInfo(t))
 688                         }
 689                         return makeStdInt64ValueMarshaler(getMarshalInfo(t))
 690                 case reflect.Uint64:
 691                         if pointer {
 692                                 if slice {
 693                                         return makeStdUInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
 694                                 }
 695                                 return makeStdUInt64ValuePtrMarshaler(getMarshalInfo(t))
 696                         }
 697                         if slice {
 698                                 return makeStdUInt64ValueSliceMarshaler(getMarshalInfo(t))
 699                         }
 700                         return makeStdUInt64ValueMarshaler(getMarshalInfo(t))
 701                 case reflect.Int32:
 702                         if pointer {
 703                                 if slice {
 704                                         return makeStdInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
 705                                 }
 706                                 return makeStdInt32ValuePtrMarshaler(getMarshalInfo(t))
 707                         }
 708                         if slice {
 709                                 return makeStdInt32ValueSliceMarshaler(getMarshalInfo(t))
 710                         }
 711                         return makeStdInt32ValueMarshaler(getMarshalInfo(t))
 712                 case reflect.Uint32:
 713                         if pointer {
 714                                 if slice {
 715                                         return makeStdUInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
 716                                 }
 717                                 return makeStdUInt32ValuePtrMarshaler(getMarshalInfo(t))
 718                         }
 719                         if slice {
 720                                 return makeStdUInt32ValueSliceMarshaler(getMarshalInfo(t))
 721                         }
 722                         return makeStdUInt32ValueMarshaler(getMarshalInfo(t))
 723                 case reflect.Bool:
 724                         if pointer {
 725                                 if slice {
 726                                         return makeStdBoolValuePtrSliceMarshaler(getMarshalInfo(t))
 727                                 }
 728                                 return makeStdBoolValuePtrMarshaler(getMarshalInfo(t))
 729                         }
 730                         if slice {
 731                                 return makeStdBoolValueSliceMarshaler(getMarshalInfo(t))
 732                         }
 733                         return makeStdBoolValueMarshaler(getMarshalInfo(t))
 734                 case reflect.String:
 735                         if pointer {
 736                                 if slice {
 737                                         return makeStdStringValuePtrSliceMarshaler(getMarshalInfo(t))
 738                                 }
 739                                 return makeStdStringValuePtrMarshaler(getMarshalInfo(t))
 740                         }
 741                         if slice {
 742                                 return makeStdStringValueSliceMarshaler(getMarshalInfo(t))
 743                         }
 744                         return makeStdStringValueMarshaler(getMarshalInfo(t))
 745                 case uint8SliceType:
 746                         if pointer {
 747                                 if slice {
 748                                         return makeStdBytesValuePtrSliceMarshaler(getMarshalInfo(t))
 749                                 }
 750                                 return makeStdBytesValuePtrMarshaler(getMarshalInfo(t))
 751                         }
 752                         if slice {
 753                                 return makeStdBytesValueSliceMarshaler(getMarshalInfo(t))
 754                         }
 755                         return makeStdBytesValueMarshaler(getMarshalInfo(t))
 756                 default:
 757                         panic(fmt.Sprintf("unknown wktpointer type %#v", t))
 758                 }
 759         }
 760
 761         switch t.Kind() {
 762         case reflect.Bool:
 763                 if pointer {
 764                         return sizeBoolPtr, appendBoolPtr
 765                 }
 766                 if slice {
 767                         if packed {
 768                                 return sizeBoolPackedSlice, appendBoolPackedSlice
 769                         }
 770                         return sizeBoolSlice, appendBoolSlice
 771                 }
 772                 if nozero {
 773                         return sizeBoolValueNoZero, appendBoolValueNoZero
 774                 }
 775                 return sizeBoolValue, appendBoolValue
 776         case reflect.Uint32:
 777                 switch encoding {
 778                 case "fixed32":
 779                         if pointer {
 780                                 return sizeFixed32Ptr, appendFixed32Ptr
 781                         }
 782                         if slice {
 783                                 if packed {
 784                                         return sizeFixed32PackedSlice, appendFixed32PackedSlice
 785                                 }
 786                                 return sizeFixed32Slice, appendFixed32Slice
 787                         }
 788                         if nozero {
 789                                 return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
 790                         }
 791                         return sizeFixed32Value, appendFixed32Value
 792                 case "varint":
 793                         if pointer {
 794                                 return sizeVarint32Ptr, appendVarint32Ptr
 795                         }
 796                         if slice {
 797                                 if packed {
 798                                         return sizeVarint32PackedSlice, appendVarint32PackedSlice
 799                                 }
 800                                 return sizeVarint32Slice, appendVarint32Slice
 801                         }
 802                         if nozero {
 803                                 return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
 804                         }
 805                         return sizeVarint32Value, appendVarint32Value
 806                 }
 807         case reflect.Int32:
 808                 switch encoding {
 809                 case "fixed32":
 810                         if pointer {
 811                                 return sizeFixedS32Ptr, appendFixedS32Ptr
 812                         }
 813                         if slice {
 814                                 if packed {
 815                                         return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
 816                                 }
 817                                 return sizeFixedS32Slice, appendFixedS32Slice
 818                         }
 819                         if nozero {
 820                                 return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
 821                         }
 822                         return sizeFixedS32Value, appendFixedS32Value
 823                 case "varint":
 824                         if pointer {
 825                                 return sizeVarintS32Ptr, appendVarintS32Ptr
 826                         }
 827                         if slice {
 828                                 if packed {
 829                                         return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
 830                                 }
 831                                 return sizeVarintS32Slice, appendVarintS32Slice
 832                         }
 833                         if nozero {
 834                                 return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
 835                         }
 836                         return sizeVarintS32Value, appendVarintS32Value
 837                 case "zigzag32":
 838                         if pointer {
 839                                 return sizeZigzag32Ptr, appendZigzag32Ptr
 840                         }
 841                         if slice {
 842                                 if packed {
 843                                         return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
 844                                 }
 845                                 return sizeZigzag32Slice, appendZigzag32Slice
 846                         }
 847                         if nozero {
 848                                 return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
 849                         }
 850                         return sizeZigzag32Value, appendZigzag32Value
 851                 }
 852         case reflect.Uint64:
 853                 switch encoding {
 854                 case "fixed64":
 855                         if pointer {
 856                                 return sizeFixed64Ptr, appendFixed64Ptr
 857                         }
 858                         if slice {
 859                                 if packed {
 860                                         return sizeFixed64PackedSlice, appendFixed64PackedSlice
 861                                 }
 862                                 return sizeFixed64Slice, appendFixed64Slice
 863                         }
 864                         if nozero {
 865                                 return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
 866                         }
 867                         return sizeFixed64Value, appendFixed64Value
 868                 case "varint":
 869                         if pointer {
 870                                 return sizeVarint64Ptr, appendVarint64Ptr
 871                         }
 872                         if slice {
 873                                 if packed {
 874                                         return sizeVarint64PackedSlice, appendVarint64PackedSlice
 875                                 }
 876                                 return sizeVarint64Slice, appendVarint64Slice
 877                         }
 878                         if nozero {
 879                                 return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
 880                         }
 881                         return sizeVarint64Value, appendVarint64Value
 882                 }
 883         case reflect.Int64:
 884                 switch encoding {
 885                 case "fixed64":
 886                         if pointer {
 887                                 return sizeFixedS64Ptr, appendFixedS64Ptr
 888                         }
 889                         if slice {
 890                                 if packed {
 891                                         return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
 892                                 }
 893                                 return sizeFixedS64Slice, appendFixedS64Slice
 894                         }
 895                         if nozero {
 896                                 return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
 897                         }
 898                         return sizeFixedS64Value, appendFixedS64Value
 899                 case "varint":
 900                         if pointer {
 901                                 return sizeVarintS64Ptr, appendVarintS64Ptr
 902                         }
 903                         if slice {
 904                                 if packed {
 905                                         return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
 906                                 }
 907                                 return sizeVarintS64Slice, appendVarintS64Slice
 908                         }
 909                         if nozero {
 910                                 return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
 911                         }
 912                         return sizeVarintS64Value, appendVarintS64Value
 913                 case "zigzag64":
 914                         if pointer {
 915                                 return sizeZigzag64Ptr, appendZigzag64Ptr
 916                         }
 917                         if slice {
 918                                 if packed {
 919                                         return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
 920                                 }
 921                                 return sizeZigzag64Slice, appendZigzag64Slice
 922                         }
 923                         if nozero {
 924                                 return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
 925                         }
 926                         return sizeZigzag64Value, appendZigzag64Value
 927                 }
 928         case reflect.Float32:
 929                 if pointer {
 930                         return sizeFloat32Ptr, appendFloat32Ptr
 931                 }
 932                 if slice {
 933                         if packed {
 934                                 return sizeFloat32PackedSlice, appendFloat32PackedSlice
 935                         }
 936                         return sizeFloat32Slice, appendFloat32Slice
 937                 }
 938                 if nozero {
 939                         return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
 940                 }
 941                 return sizeFloat32Value, appendFloat32Value
 942         case reflect.Float64:
 943                 if pointer {
 944                         return sizeFloat64Ptr, appendFloat64Ptr
 945                 }
 946                 if slice {
 947                         if packed {
 948                                 return sizeFloat64PackedSlice, appendFloat64PackedSlice
 949                         }
 950                         return sizeFloat64Slice, appendFloat64Slice
 951                 }
 952                 if nozero {
 953                         return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
 954                 }
 955                 return sizeFloat64Value, appendFloat64Value
 956         case reflect.String:
 957                 if validateUTF8 {
 958                         if pointer {
 959                                 return sizeStringPtr, appendUTF8StringPtr
 960                         }
 961                         if slice {
 962                                 return sizeStringSlice, appendUTF8StringSlice
 963                         }
 964                         if nozero {
 965                                 return sizeStringValueNoZero, appendUTF8StringValueNoZero
 966                         }
 967                         return sizeStringValue, appendUTF8StringValue
 968                 }
 969                 if pointer {
 970                         return sizeStringPtr, appendStringPtr
 971                 }
 972                 if slice {
 973                         return sizeStringSlice, appendStringSlice
 974                 }
 975                 if nozero {
 976                         return sizeStringValueNoZero, appendStringValueNoZero
 977                 }
 978                 return sizeStringValue, appendStringValue
 979         case reflect.Slice:
 980                 if slice {
 981                         return sizeBytesSlice, appendBytesSlice
 982                 }
 983                 if oneof {
 984                         // Oneof bytes field may also have "proto3" tag.
 985                         // We want to marshal it as a oneof field. Do this
 986                         // check before the proto3 check.
 987                         return sizeBytesOneof, appendBytesOneof
 988                 }
 989                 if proto3 {
 990                         return sizeBytes3, appendBytes3
 991                 }
 992                 return sizeBytes, appendBytes
 993         case reflect.Struct:
 994                 switch encoding {
 995                 case "group":
 996                         if slice {
 997                                 return makeGroupSliceMarshaler(getMarshalInfo(t))
 998                         }
 999                         return makeGroupMarshaler(getMarshalInfo(t))
1000                 case "bytes":
1001                         if pointer {
1002                                 if slice {
1003                                         return makeMessageSliceMarshaler(getMarshalInfo(t))
1004                                 }
1005                                 return makeMessageMarshaler(getMarshalInfo(t))
1006                         } else {
1007                                 if slice {
1008                                         return makeMessageRefSliceMarshaler(getMarshalInfo(t))
1009                                 }
1010                                 return makeMessageRefMarshaler(getMarshalInfo(t))
1011                         }
1012                 }
1013         }
1014         panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
1015 }
1016
1017 // Below are functions to size/marshal a specific type of a field.
1018 // They are stored in the field's info, and called by function pointers.
1019 // They have type sizer or marshaler.
1020
1021 func sizeFixed32Value(_ pointer, tagsize int) int {
1022         return 4 + tagsize
1023 }
1024 func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
1025         v := *ptr.toUint32()
1026         if v == 0 {
1027                 return 0
1028         }
1029         return 4 + tagsize
1030 }
1031 func sizeFixed32Ptr(ptr pointer, tagsize int) int {
1032         p := *ptr.toUint32Ptr()
1033         if p == nil {
1034                 return 0
1035         }
1036         return 4 + tagsize
1037 }
1038 func sizeFixed32Slice(ptr pointer, tagsize int) int {
1039         s := *ptr.toUint32Slice()
1040         return (4 + tagsize) * len(s)
1041 }
1042 func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
1043         s := *ptr.toUint32Slice()
1044         if len(s) == 0 {
1045                 return 0
1046         }
1047         return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1048 }
1049 func sizeFixedS32Value(_ pointer, tagsize int) int {
1050         return 4 + tagsize
1051 }
1052 func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
1053         v := *ptr.toInt32()
1054         if v == 0 {
1055                 return 0
1056         }
1057         return 4 + tagsize
1058 }
1059 func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
1060         p := ptr.getInt32Ptr()
1061         if p == nil {
1062                 return 0
1063         }
1064         return 4 + tagsize
1065 }
1066 func sizeFixedS32Slice(ptr pointer, tagsize int) int {
1067         s := ptr.getInt32Slice()
1068         return (4 + tagsize) * len(s)
1069 }
1070 func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
1071         s := ptr.getInt32Slice()
1072         if len(s) == 0 {
1073                 return 0
1074         }
1075         return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1076 }
1077 func sizeFloat32Value(_ pointer, tagsize int) int {
1078         return 4 + tagsize
1079 }
1080 func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
1081         v := math.Float32bits(*ptr.toFloat32())
1082         if v == 0 {
1083                 return 0
1084         }
1085         return 4 + tagsize
1086 }
1087 func sizeFloat32Ptr(ptr pointer, tagsize int) int {
1088         p := *ptr.toFloat32Ptr()
1089         if p == nil {
1090                 return 0
1091         }
1092         return 4 + tagsize
1093 }
1094 func sizeFloat32Slice(ptr pointer, tagsize int) int {
1095         s := *ptr.toFloat32Slice()
1096         return (4 + tagsize) * len(s)
1097 }
1098 func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
1099         s := *ptr.toFloat32Slice()
1100         if len(s) == 0 {
1101                 return 0
1102         }
1103         return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1104 }
1105 func sizeFixed64Value(_ pointer, tagsize int) int {
1106         return 8 + tagsize
1107 }
1108 func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
1109         v := *ptr.toUint64()
1110         if v == 0 {
1111                 return 0
1112         }
1113         return 8 + tagsize
1114 }
1115 func sizeFixed64Ptr(ptr pointer, tagsize int) int {
1116         p := *ptr.toUint64Ptr()
1117         if p == nil {
1118                 return 0
1119         }
1120         return 8 + tagsize
1121 }
1122 func sizeFixed64Slice(ptr pointer, tagsize int) int {
1123         s := *ptr.toUint64Slice()
1124         return (8 + tagsize) * len(s)
1125 }
1126 func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
1127         s := *ptr.toUint64Slice()
1128         if len(s) == 0 {
1129                 return 0
1130         }
1131         return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1132 }
1133 func sizeFixedS64Value(_ pointer, tagsize int) int {
1134         return 8 + tagsize
1135 }
1136 func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
1137         v := *ptr.toInt64()
1138         if v == 0 {
1139                 return 0
1140         }
1141         return 8 + tagsize
1142 }
1143 func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
1144         p := *ptr.toInt64Ptr()
1145         if p == nil {
1146                 return 0
1147         }
1148         return 8 + tagsize
1149 }
1150 func sizeFixedS64Slice(ptr pointer, tagsize int) int {
1151         s := *ptr.toInt64Slice()
1152         return (8 + tagsize) * len(s)
1153 }
1154 func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
1155         s := *ptr.toInt64Slice()
1156         if len(s) == 0 {
1157                 return 0
1158         }
1159         return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1160 }
1161 func sizeFloat64Value(_ pointer, tagsize int) int {
1162         return 8 + tagsize
1163 }
1164 func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
1165         v := math.Float64bits(*ptr.toFloat64())
1166         if v == 0 {
1167                 return 0
1168         }
1169         return 8 + tagsize
1170 }
1171 func sizeFloat64Ptr(ptr pointer, tagsize int) int {
1172         p := *ptr.toFloat64Ptr()
1173         if p == nil {
1174                 return 0
1175         }
1176         return 8 + tagsize
1177 }
1178 func sizeFloat64Slice(ptr pointer, tagsize int) int {
1179         s := *ptr.toFloat64Slice()
1180         return (8 + tagsize) * len(s)
1181 }
1182 func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
1183         s := *ptr.toFloat64Slice()
1184         if len(s) == 0 {
1185                 return 0
1186         }
1187         return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1188 }
1189 func sizeVarint32Value(ptr pointer, tagsize int) int {
1190         v := *ptr.toUint32()
1191         return SizeVarint(uint64(v)) + tagsize
1192 }
1193 func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
1194         v := *ptr.toUint32()
1195         if v == 0 {
1196                 return 0
1197         }
1198         return SizeVarint(uint64(v)) + tagsize
1199 }
1200 func sizeVarint32Ptr(ptr pointer, tagsize int) int {
1201         p := *ptr.toUint32Ptr()
1202         if p == nil {
1203                 return 0
1204         }
1205         return SizeVarint(uint64(*p)) + tagsize
1206 }
1207 func sizeVarint32Slice(ptr pointer, tagsize int) int {
1208         s := *ptr.toUint32Slice()
1209         n := 0
1210         for _, v := range s {
1211                 n += SizeVarint(uint64(v)) + tagsize
1212         }
1213         return n
1214 }
1215 func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
1216         s := *ptr.toUint32Slice()
1217         if len(s) == 0 {
1218                 return 0
1219         }
1220         n := 0
1221         for _, v := range s {
1222                 n += SizeVarint(uint64(v))
1223         }
1224         return n + SizeVarint(uint64(n)) + tagsize
1225 }
1226 func sizeVarintS32Value(ptr pointer, tagsize int) int {
1227         v := *ptr.toInt32()
1228         return SizeVarint(uint64(v)) + tagsize
1229 }
1230 func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
1231         v := *ptr.toInt32()
1232         if v == 0 {
1233                 return 0
1234         }
1235         return SizeVarint(uint64(v)) + tagsize
1236 }
1237 func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
1238         p := ptr.getInt32Ptr()
1239         if p == nil {
1240                 return 0
1241         }
1242         return SizeVarint(uint64(*p)) + tagsize
1243 }
1244 func sizeVarintS32Slice(ptr pointer, tagsize int) int {
1245         s := ptr.getInt32Slice()
1246         n := 0
1247         for _, v := range s {
1248                 n += SizeVarint(uint64(v)) + tagsize
1249         }
1250         return n
1251 }
1252 func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
1253         s := ptr.getInt32Slice()
1254         if len(s) == 0 {
1255                 return 0
1256         }
1257         n := 0
1258         for _, v := range s {
1259                 n += SizeVarint(uint64(v))
1260         }
1261         return n + SizeVarint(uint64(n)) + tagsize
1262 }
1263 func sizeVarint64Value(ptr pointer, tagsize int) int {
1264         v := *ptr.toUint64()
1265         return SizeVarint(v) + tagsize
1266 }
1267 func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
1268         v := *ptr.toUint64()
1269         if v == 0 {
1270                 return 0
1271         }
1272         return SizeVarint(v) + tagsize
1273 }
1274 func sizeVarint64Ptr(ptr pointer, tagsize int) int {
1275         p := *ptr.toUint64Ptr()
1276         if p == nil {
1277                 return 0
1278         }
1279         return SizeVarint(*p) + tagsize
1280 }
1281 func sizeVarint64Slice(ptr pointer, tagsize int) int {
1282         s := *ptr.toUint64Slice()
1283         n := 0
1284         for _, v := range s {
1285                 n += SizeVarint(v) + tagsize
1286         }
1287         return n
1288 }
1289 func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
1290         s := *ptr.toUint64Slice()
1291         if len(s) == 0 {
1292                 return 0
1293         }
1294         n := 0
1295         for _, v := range s {
1296                 n += SizeVarint(v)
1297         }
1298         return n + SizeVarint(uint64(n)) + tagsize
1299 }
1300 func sizeVarintS64Value(ptr pointer, tagsize int) int {
1301         v := *ptr.toInt64()
1302         return SizeVarint(uint64(v)) + tagsize
1303 }
1304 func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
1305         v := *ptr.toInt64()
1306         if v == 0 {
1307                 return 0
1308         }
1309         return SizeVarint(uint64(v)) + tagsize
1310 }
1311 func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
1312         p := *ptr.toInt64Ptr()
1313         if p == nil {
1314                 return 0
1315         }
1316         return SizeVarint(uint64(*p)) + tagsize
1317 }
1318 func sizeVarintS64Slice(ptr pointer, tagsize int) int {
1319         s := *ptr.toInt64Slice()
1320         n := 0
1321         for _, v := range s {
1322                 n += SizeVarint(uint64(v)) + tagsize
1323         }
1324         return n
1325 }
1326 func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
1327         s := *ptr.toInt64Slice()
1328         if len(s) == 0 {
1329                 return 0
1330         }
1331         n := 0
1332         for _, v := range s {
1333                 n += SizeVarint(uint64(v))
1334         }
1335         return n + SizeVarint(uint64(n)) + tagsize
1336 }
1337 func sizeZigzag32Value(ptr pointer, tagsize int) int {
1338         v := *ptr.toInt32()
1339         return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1340 }
1341 func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
1342         v := *ptr.toInt32()
1343         if v == 0 {
1344                 return 0
1345         }
1346         return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1347 }
1348 func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
1349         p := ptr.getInt32Ptr()
1350         if p == nil {
1351                 return 0
1352         }
1353         v := *p
1354         return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1355 }
1356 func sizeZigzag32Slice(ptr pointer, tagsize int) int {
1357         s := ptr.getInt32Slice()
1358         n := 0
1359         for _, v := range s {
1360                 n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1361         }
1362         return n
1363 }
1364 func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
1365         s := ptr.getInt32Slice()
1366         if len(s) == 0 {
1367                 return 0
1368         }
1369         n := 0
1370         for _, v := range s {
1371                 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
1372         }
1373         return n + SizeVarint(uint64(n)) + tagsize
1374 }
1375 func sizeZigzag64Value(ptr pointer, tagsize int) int {
1376         v := *ptr.toInt64()
1377         return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1378 }
1379 func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
1380         v := *ptr.toInt64()
1381         if v == 0 {
1382                 return 0
1383         }
1384         return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1385 }
1386 func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
1387         p := *ptr.toInt64Ptr()
1388         if p == nil {
1389                 return 0
1390         }
1391         v := *p
1392         return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1393 }
1394 func sizeZigzag64Slice(ptr pointer, tagsize int) int {
1395         s := *ptr.toInt64Slice()
1396         n := 0
1397         for _, v := range s {
1398                 n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1399         }
1400         return n
1401 }
1402 func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
1403         s := *ptr.toInt64Slice()
1404         if len(s) == 0 {
1405                 return 0
1406         }
1407         n := 0
1408         for _, v := range s {
1409                 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
1410         }
1411         return n + SizeVarint(uint64(n)) + tagsize
1412 }
1413 func sizeBoolValue(_ pointer, tagsize int) int {
1414         return 1 + tagsize
1415 }
1416 func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
1417         v := *ptr.toBool()
1418         if !v {
1419                 return 0
1420         }
1421         return 1 + tagsize
1422 }
1423 func sizeBoolPtr(ptr pointer, tagsize int) int {
1424         p := *ptr.toBoolPtr()
1425         if p == nil {
1426                 return 0
1427         }
1428         return 1 + tagsize
1429 }
1430 func sizeBoolSlice(ptr pointer, tagsize int) int {
1431         s := *ptr.toBoolSlice()
1432         return (1 + tagsize) * len(s)
1433 }
1434 func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
1435         s := *ptr.toBoolSlice()
1436         if len(s) == 0 {
1437                 return 0
1438         }
1439         return len(s) + SizeVarint(uint64(len(s))) + tagsize
1440 }
1441 func sizeStringValue(ptr pointer, tagsize int) int {
1442         v := *ptr.toString()
1443         return len(v) + SizeVarint(uint64(len(v))) + tagsize
1444 }
1445 func sizeStringValueNoZero(ptr pointer, tagsize int) int {
1446         v := *ptr.toString()
1447         if v == "" {
1448                 return 0
1449         }
1450         return len(v) + SizeVarint(uint64(len(v))) + tagsize
1451 }
1452 func sizeStringPtr(ptr pointer, tagsize int) int {
1453         p := *ptr.toStringPtr()
1454         if p == nil {
1455                 return 0
1456         }
1457         v := *p
1458         return len(v) + SizeVarint(uint64(len(v))) + tagsize
1459 }
1460 func sizeStringSlice(ptr pointer, tagsize int) int {
1461         s := *ptr.toStringSlice()
1462         n := 0
1463         for _, v := range s {
1464                 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1465         }
1466         return n
1467 }
1468 func sizeBytes(ptr pointer, tagsize int) int {
1469         v := *ptr.toBytes()
1470         if v == nil {
1471                 return 0
1472         }
1473         return len(v) + SizeVarint(uint64(len(v))) + tagsize
1474 }
1475 func sizeBytes3(ptr pointer, tagsize int) int {
1476         v := *ptr.toBytes()
1477         if len(v) == 0 {
1478                 return 0
1479         }
1480         return len(v) + SizeVarint(uint64(len(v))) + tagsize
1481 }
1482 func sizeBytesOneof(ptr pointer, tagsize int) int {
1483         v := *ptr.toBytes()
1484         return len(v) + SizeVarint(uint64(len(v))) + tagsize
1485 }
1486 func sizeBytesSlice(ptr pointer, tagsize int) int {
1487         s := *ptr.toBytesSlice()
1488         n := 0
1489         for _, v := range s {
1490                 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1491         }
1492         return n
1493 }
1494
1495 // appendFixed32 appends an encoded fixed32 to b.
1496 func appendFixed32(b []byte, v uint32) []byte {
1497         b = append(b,
1498                 byte(v),
1499                 byte(v>>8),
1500                 byte(v>>16),
1501                 byte(v>>24))
1502         return b
1503 }
1504
1505 // appendFixed64 appends an encoded fixed64 to b.
1506 func appendFixed64(b []byte, v uint64) []byte {
1507         b = append(b,
1508                 byte(v),
1509                 byte(v>>8),
1510                 byte(v>>16),
1511                 byte(v>>24),
1512                 byte(v>>32),
1513                 byte(v>>40),
1514                 byte(v>>48),
1515                 byte(v>>56))
1516         return b
1517 }
1518
1519 // appendVarint appends an encoded varint to b.
1520 func appendVarint(b []byte, v uint64) []byte {
1521         // TODO: make 1-byte (maybe 2-byte) case inline-able, once we
1522         // have non-leaf inliner.
1523         switch {
1524         case v < 1<<7:
1525                 b = append(b, byte(v))
1526         case v < 1<<14:
1527                 b = append(b,
1528                         byte(v&0x7f|0x80),
1529                         byte(v>>7))
1530         case v < 1<<21:
1531                 b = append(b,
1532                         byte(v&0x7f|0x80),
1533                         byte((v>>7)&0x7f|0x80),
1534                         byte(v>>14))
1535         case v < 1<<28:
1536                 b = append(b,
1537                         byte(v&0x7f|0x80),
1538                         byte((v>>7)&0x7f|0x80),
1539                         byte((v>>14)&0x7f|0x80),
1540                         byte(v>>21))
1541         case v < 1<<35:
1542                 b = append(b,
1543                         byte(v&0x7f|0x80),
1544                         byte((v>>7)&0x7f|0x80),
1545                         byte((v>>14)&0x7f|0x80),
1546                         byte((v>>21)&0x7f|0x80),
1547                         byte(v>>28))
1548         case v < 1<<42:
1549                 b = append(b,
1550                         byte(v&0x7f|0x80),
1551                         byte((v>>7)&0x7f|0x80),
1552                         byte((v>>14)&0x7f|0x80),
1553                         byte((v>>21)&0x7f|0x80),
1554                         byte((v>>28)&0x7f|0x80),
1555                         byte(v>>35))
1556         case v < 1<<49:
1557                 b = append(b,
1558                         byte(v&0x7f|0x80),
1559                         byte((v>>7)&0x7f|0x80),
1560                         byte((v>>14)&0x7f|0x80),
1561                         byte((v>>21)&0x7f|0x80),
1562                         byte((v>>28)&0x7f|0x80),
1563                         byte((v>>35)&0x7f|0x80),
1564                         byte(v>>42))
1565         case v < 1<<56:
1566                 b = append(b,
1567                         byte(v&0x7f|0x80),
1568                         byte((v>>7)&0x7f|0x80),
1569                         byte((v>>14)&0x7f|0x80),
1570                         byte((v>>21)&0x7f|0x80),
1571                         byte((v>>28)&0x7f|0x80),
1572                         byte((v>>35)&0x7f|0x80),
1573                         byte((v>>42)&0x7f|0x80),
1574                         byte(v>>49))
1575         case v < 1<<63:
1576                 b = append(b,
1577                         byte(v&0x7f|0x80),
1578                         byte((v>>7)&0x7f|0x80),
1579                         byte((v>>14)&0x7f|0x80),
1580                         byte((v>>21)&0x7f|0x80),
1581                         byte((v>>28)&0x7f|0x80),
1582                         byte((v>>35)&0x7f|0x80),
1583                         byte((v>>42)&0x7f|0x80),
1584                         byte((v>>49)&0x7f|0x80),
1585                         byte(v>>56))
1586         default:
1587                 b = append(b,
1588                         byte(v&0x7f|0x80),
1589                         byte((v>>7)&0x7f|0x80),
1590                         byte((v>>14)&0x7f|0x80),
1591                         byte((v>>21)&0x7f|0x80),
1592                         byte((v>>28)&0x7f|0x80),
1593                         byte((v>>35)&0x7f|0x80),
1594                         byte((v>>42)&0x7f|0x80),
1595                         byte((v>>49)&0x7f|0x80),
1596                         byte((v>>56)&0x7f|0x80),
1597                         1)
1598         }
1599         return b
1600 }
1601
1602 func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1603         v := *ptr.toUint32()
1604         b = appendVarint(b, wiretag)
1605         b = appendFixed32(b, v)
1606         return b, nil
1607 }
1608 func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1609         v := *ptr.toUint32()
1610         if v == 0 {
1611                 return b, nil
1612         }
1613         b = appendVarint(b, wiretag)
1614         b = appendFixed32(b, v)
1615         return b, nil
1616 }
1617 func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1618         p := *ptr.toUint32Ptr()
1619         if p == nil {
1620                 return b, nil
1621         }
1622         b = appendVarint(b, wiretag)
1623         b = appendFixed32(b, *p)
1624         return b, nil
1625 }
1626 func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1627         s := *ptr.toUint32Slice()
1628         for _, v := range s {
1629                 b = appendVarint(b, wiretag)
1630                 b = appendFixed32(b, v)
1631         }
1632         return b, nil
1633 }
1634 func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1635         s := *ptr.toUint32Slice()
1636         if len(s) == 0 {
1637                 return b, nil
1638         }
1639         b = appendVarint(b, wiretag&^7|WireBytes)
1640         b = appendVarint(b, uint64(4*len(s)))
1641         for _, v := range s {
1642                 b = appendFixed32(b, v)
1643         }
1644         return b, nil
1645 }
1646 func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1647         v := *ptr.toInt32()
1648         b = appendVarint(b, wiretag)
1649         b = appendFixed32(b, uint32(v))
1650         return b, nil
1651 }
1652 func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1653         v := *ptr.toInt32()
1654         if v == 0 {
1655                 return b, nil
1656         }
1657         b = appendVarint(b, wiretag)
1658         b = appendFixed32(b, uint32(v))
1659         return b, nil
1660 }
1661 func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1662         p := ptr.getInt32Ptr()
1663         if p == nil {
1664                 return b, nil
1665         }
1666         b = appendVarint(b, wiretag)
1667         b = appendFixed32(b, uint32(*p))
1668         return b, nil
1669 }
1670 func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1671         s := ptr.getInt32Slice()
1672         for _, v := range s {
1673                 b = appendVarint(b, wiretag)
1674                 b = appendFixed32(b, uint32(v))
1675         }
1676         return b, nil
1677 }
1678 func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1679         s := ptr.getInt32Slice()
1680         if len(s) == 0 {
1681                 return b, nil
1682         }
1683         b = appendVarint(b, wiretag&^7|WireBytes)
1684         b = appendVarint(b, uint64(4*len(s)))
1685         for _, v := range s {
1686                 b = appendFixed32(b, uint32(v))
1687         }
1688         return b, nil
1689 }
1690 func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1691         v := math.Float32bits(*ptr.toFloat32())
1692         b = appendVarint(b, wiretag)
1693         b = appendFixed32(b, v)
1694         return b, nil
1695 }
1696 func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1697         v := math.Float32bits(*ptr.toFloat32())
1698         if v == 0 {
1699                 return b, nil
1700         }
1701         b = appendVarint(b, wiretag)
1702         b = appendFixed32(b, v)
1703         return b, nil
1704 }
1705 func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1706         p := *ptr.toFloat32Ptr()
1707         if p == nil {
1708                 return b, nil
1709         }
1710         b = appendVarint(b, wiretag)
1711         b = appendFixed32(b, math.Float32bits(*p))
1712         return b, nil
1713 }
1714 func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1715         s := *ptr.toFloat32Slice()
1716         for _, v := range s {
1717                 b = appendVarint(b, wiretag)
1718                 b = appendFixed32(b, math.Float32bits(v))
1719         }
1720         return b, nil
1721 }
1722 func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1723         s := *ptr.toFloat32Slice()
1724         if len(s) == 0 {
1725                 return b, nil
1726         }
1727         b = appendVarint(b, wiretag&^7|WireBytes)
1728         b = appendVarint(b, uint64(4*len(s)))
1729         for _, v := range s {
1730                 b = appendFixed32(b, math.Float32bits(v))
1731         }
1732         return b, nil
1733 }
1734 func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1735         v := *ptr.toUint64()
1736         b = appendVarint(b, wiretag)
1737         b = appendFixed64(b, v)
1738         return b, nil
1739 }
1740 func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1741         v := *ptr.toUint64()
1742         if v == 0 {
1743                 return b, nil
1744         }
1745         b = appendVarint(b, wiretag)
1746         b = appendFixed64(b, v)
1747         return b, nil
1748 }
1749 func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1750         p := *ptr.toUint64Ptr()
1751         if p == nil {
1752                 return b, nil
1753         }
1754         b = appendVarint(b, wiretag)
1755         b = appendFixed64(b, *p)
1756         return b, nil
1757 }
1758 func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1759         s := *ptr.toUint64Slice()
1760         for _, v := range s {
1761                 b = appendVarint(b, wiretag)
1762                 b = appendFixed64(b, v)
1763         }
1764         return b, nil
1765 }
1766 func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1767         s := *ptr.toUint64Slice()
1768         if len(s) == 0 {
1769                 return b, nil
1770         }
1771         b = appendVarint(b, wiretag&^7|WireBytes)
1772         b = appendVarint(b, uint64(8*len(s)))
1773         for _, v := range s {
1774                 b = appendFixed64(b, v)
1775         }
1776         return b, nil
1777 }
1778 func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1779         v := *ptr.toInt64()
1780         b = appendVarint(b, wiretag)
1781         b = appendFixed64(b, uint64(v))
1782         return b, nil
1783 }
1784 func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1785         v := *ptr.toInt64()
1786         if v == 0 {
1787                 return b, nil
1788         }
1789         b = appendVarint(b, wiretag)
1790         b = appendFixed64(b, uint64(v))
1791         return b, nil
1792 }
1793 func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1794         p := *ptr.toInt64Ptr()
1795         if p == nil {
1796                 return b, nil
1797         }
1798         b = appendVarint(b, wiretag)
1799         b = appendFixed64(b, uint64(*p))
1800         return b, nil
1801 }
1802 func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1803         s := *ptr.toInt64Slice()
1804         for _, v := range s {
1805                 b = appendVarint(b, wiretag)
1806                 b = appendFixed64(b, uint64(v))
1807         }
1808         return b, nil
1809 }
1810 func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1811         s := *ptr.toInt64Slice()
1812         if len(s) == 0 {
1813                 return b, nil
1814         }
1815         b = appendVarint(b, wiretag&^7|WireBytes)
1816         b = appendVarint(b, uint64(8*len(s)))
1817         for _, v := range s {
1818                 b = appendFixed64(b, uint64(v))
1819         }
1820         return b, nil
1821 }
1822 func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1823         v := math.Float64bits(*ptr.toFloat64())
1824         b = appendVarint(b, wiretag)
1825         b = appendFixed64(b, v)
1826         return b, nil
1827 }
1828 func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1829         v := math.Float64bits(*ptr.toFloat64())
1830         if v == 0 {
1831                 return b, nil
1832         }
1833         b = appendVarint(b, wiretag)
1834         b = appendFixed64(b, v)
1835         return b, nil
1836 }
1837 func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1838         p := *ptr.toFloat64Ptr()
1839         if p == nil {
1840                 return b, nil
1841         }
1842         b = appendVarint(b, wiretag)
1843         b = appendFixed64(b, math.Float64bits(*p))
1844         return b, nil
1845 }
1846 func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1847         s := *ptr.toFloat64Slice()
1848         for _, v := range s {
1849                 b = appendVarint(b, wiretag)
1850                 b = appendFixed64(b, math.Float64bits(v))
1851         }
1852         return b, nil
1853 }
1854 func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1855         s := *ptr.toFloat64Slice()
1856         if len(s) == 0 {
1857                 return b, nil
1858         }
1859         b = appendVarint(b, wiretag&^7|WireBytes)
1860         b = appendVarint(b, uint64(8*len(s)))
1861         for _, v := range s {
1862                 b = appendFixed64(b, math.Float64bits(v))
1863         }
1864         return b, nil
1865 }
1866 func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1867         v := *ptr.toUint32()
1868         b = appendVarint(b, wiretag)
1869         b = appendVarint(b, uint64(v))
1870         return b, nil
1871 }
1872 func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1873         v := *ptr.toUint32()
1874         if v == 0 {
1875                 return b, nil
1876         }
1877         b = appendVarint(b, wiretag)
1878         b = appendVarint(b, uint64(v))
1879         return b, nil
1880 }
1881 func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1882         p := *ptr.toUint32Ptr()
1883         if p == nil {
1884                 return b, nil
1885         }
1886         b = appendVarint(b, wiretag)
1887         b = appendVarint(b, uint64(*p))
1888         return b, nil
1889 }
1890 func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1891         s := *ptr.toUint32Slice()
1892         for _, v := range s {
1893                 b = appendVarint(b, wiretag)
1894                 b = appendVarint(b, uint64(v))
1895         }
1896         return b, nil
1897 }
1898 func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1899         s := *ptr.toUint32Slice()
1900         if len(s) == 0 {
1901                 return b, nil
1902         }
1903         b = appendVarint(b, wiretag&^7|WireBytes)
1904         // compute size
1905         n := 0
1906         for _, v := range s {
1907                 n += SizeVarint(uint64(v))
1908         }
1909         b = appendVarint(b, uint64(n))
1910         for _, v := range s {
1911                 b = appendVarint(b, uint64(v))
1912         }
1913         return b, nil
1914 }
1915 func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1916         v := *ptr.toInt32()
1917         b = appendVarint(b, wiretag)
1918         b = appendVarint(b, uint64(v))
1919         return b, nil
1920 }
1921 func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1922         v := *ptr.toInt32()
1923         if v == 0 {
1924                 return b, nil
1925         }
1926         b = appendVarint(b, wiretag)
1927         b = appendVarint(b, uint64(v))
1928         return b, nil
1929 }
1930 func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1931         p := ptr.getInt32Ptr()
1932         if p == nil {
1933                 return b, nil
1934         }
1935         b = appendVarint(b, wiretag)
1936         b = appendVarint(b, uint64(*p))
1937         return b, nil
1938 }
1939 func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1940         s := ptr.getInt32Slice()
1941         for _, v := range s {
1942                 b = appendVarint(b, wiretag)
1943                 b = appendVarint(b, uint64(v))
1944         }
1945         return b, nil
1946 }
1947 func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1948         s := ptr.getInt32Slice()
1949         if len(s) == 0 {
1950                 return b, nil
1951         }
1952         b = appendVarint(b, wiretag&^7|WireBytes)
1953         // compute size
1954         n := 0
1955         for _, v := range s {
1956                 n += SizeVarint(uint64(v))
1957         }
1958         b = appendVarint(b, uint64(n))
1959         for _, v := range s {
1960                 b = appendVarint(b, uint64(v))
1961         }
1962         return b, nil
1963 }
1964 func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1965         v := *ptr.toUint64()
1966         b = appendVarint(b, wiretag)
1967         b = appendVarint(b, v)
1968         return b, nil
1969 }
1970 func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1971         v := *ptr.toUint64()
1972         if v == 0 {
1973                 return b, nil
1974         }
1975         b = appendVarint(b, wiretag)
1976         b = appendVarint(b, v)
1977         return b, nil
1978 }
1979 func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1980         p := *ptr.toUint64Ptr()
1981         if p == nil {
1982                 return b, nil
1983         }
1984         b = appendVarint(b, wiretag)
1985         b = appendVarint(b, *p)
1986         return b, nil
1987 }
1988 func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1989         s := *ptr.toUint64Slice()
1990         for _, v := range s {
1991                 b = appendVarint(b, wiretag)
1992                 b = appendVarint(b, v)
1993         }
1994         return b, nil
1995 }
1996 func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1997         s := *ptr.toUint64Slice()
1998         if len(s) == 0 {
1999                 return b, nil
2000         }
2001         b = appendVarint(b, wiretag&^7|WireBytes)
2002         // compute size
2003         n := 0
2004         for _, v := range s {
2005                 n += SizeVarint(v)
2006         }
2007         b = appendVarint(b, uint64(n))
2008         for _, v := range s {
2009                 b = appendVarint(b, v)
2010         }
2011         return b, nil
2012 }
2013 func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2014         v := *ptr.toInt64()
2015         b = appendVarint(b, wiretag)
2016         b = appendVarint(b, uint64(v))
2017         return b, nil
2018 }
2019 func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2020         v := *ptr.toInt64()
2021         if v == 0 {
2022                 return b, nil
2023         }
2024         b = appendVarint(b, wiretag)
2025         b = appendVarint(b, uint64(v))
2026         return b, nil
2027 }
2028 func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2029         p := *ptr.toInt64Ptr()
2030         if p == nil {
2031                 return b, nil
2032         }
2033         b = appendVarint(b, wiretag)
2034         b = appendVarint(b, uint64(*p))
2035         return b, nil
2036 }
2037 func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2038         s := *ptr.toInt64Slice()
2039         for _, v := range s {
2040                 b = appendVarint(b, wiretag)
2041                 b = appendVarint(b, uint64(v))
2042         }
2043         return b, nil
2044 }
2045 func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2046         s := *ptr.toInt64Slice()
2047         if len(s) == 0 {
2048                 return b, nil
2049         }
2050         b = appendVarint(b, wiretag&^7|WireBytes)
2051         // compute size
2052         n := 0
2053         for _, v := range s {
2054                 n += SizeVarint(uint64(v))
2055         }
2056         b = appendVarint(b, uint64(n))
2057         for _, v := range s {
2058                 b = appendVarint(b, uint64(v))
2059         }
2060         return b, nil
2061 }
2062 func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2063         v := *ptr.toInt32()
2064         b = appendVarint(b, wiretag)
2065         b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2066         return b, nil
2067 }
2068 func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2069         v := *ptr.toInt32()
2070         if v == 0 {
2071                 return b, nil
2072         }
2073         b = appendVarint(b, wiretag)
2074         b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2075         return b, nil
2076 }
2077 func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2078         p := ptr.getInt32Ptr()
2079         if p == nil {
2080                 return b, nil
2081         }
2082         b = appendVarint(b, wiretag)
2083         v := *p
2084         b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2085         return b, nil
2086 }
2087 func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2088         s := ptr.getInt32Slice()
2089         for _, v := range s {
2090                 b = appendVarint(b, wiretag)
2091                 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2092         }
2093         return b, nil
2094 }
2095 func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2096         s := ptr.getInt32Slice()
2097         if len(s) == 0 {
2098                 return b, nil
2099         }
2100         b = appendVarint(b, wiretag&^7|WireBytes)
2101         // compute size
2102         n := 0
2103         for _, v := range s {
2104                 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
2105         }
2106         b = appendVarint(b, uint64(n))
2107         for _, v := range s {
2108                 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2109         }
2110         return b, nil
2111 }
2112 func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2113         v := *ptr.toInt64()
2114         b = appendVarint(b, wiretag)
2115         b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2116         return b, nil
2117 }
2118 func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2119         v := *ptr.toInt64()
2120         if v == 0 {
2121                 return b, nil
2122         }
2123         b = appendVarint(b, wiretag)
2124         b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2125         return b, nil
2126 }
2127 func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2128         p := *ptr.toInt64Ptr()
2129         if p == nil {
2130                 return b, nil
2131         }
2132         b = appendVarint(b, wiretag)
2133         v := *p
2134         b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2135         return b, nil
2136 }
2137 func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2138         s := *ptr.toInt64Slice()
2139         for _, v := range s {
2140                 b = appendVarint(b, wiretag)
2141                 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2142         }
2143         return b, nil
2144 }
2145 func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2146         s := *ptr.toInt64Slice()
2147         if len(s) == 0 {
2148                 return b, nil
2149         }
2150         b = appendVarint(b, wiretag&^7|WireBytes)
2151         // compute size
2152         n := 0
2153         for _, v := range s {
2154                 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
2155         }
2156         b = appendVarint(b, uint64(n))
2157         for _, v := range s {
2158                 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2159         }
2160         return b, nil
2161 }
2162 func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2163         v := *ptr.toBool()
2164         b = appendVarint(b, wiretag)
2165         if v {
2166                 b = append(b, 1)
2167         } else {
2168                 b = append(b, 0)
2169         }
2170         return b, nil
2171 }
2172 func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2173         v := *ptr.toBool()
2174         if !v {
2175                 return b, nil
2176         }
2177         b = appendVarint(b, wiretag)
2178         b = append(b, 1)
2179         return b, nil
2180 }
2181
2182 func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2183         p := *ptr.toBoolPtr()
2184         if p == nil {
2185                 return b, nil
2186         }
2187         b = appendVarint(b, wiretag)
2188         if *p {
2189                 b = append(b, 1)
2190         } else {
2191                 b = append(b, 0)
2192         }
2193         return b, nil
2194 }
2195 func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2196         s := *ptr.toBoolSlice()
2197         for _, v := range s {
2198                 b = appendVarint(b, wiretag)
2199                 if v {
2200                         b = append(b, 1)
2201                 } else {
2202                         b = append(b, 0)
2203                 }
2204         }
2205         return b, nil
2206 }
2207 func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2208         s := *ptr.toBoolSlice()
2209         if len(s) == 0 {
2210                 return b, nil
2211         }
2212         b = appendVarint(b, wiretag&^7|WireBytes)
2213         b = appendVarint(b, uint64(len(s)))
2214         for _, v := range s {
2215                 if v {
2216                         b = append(b, 1)
2217                 } else {
2218                         b = append(b, 0)
2219                 }
2220         }
2221         return b, nil
2222 }
2223 func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2224         v := *ptr.toString()
2225         b = appendVarint(b, wiretag)
2226         b = appendVarint(b, uint64(len(v)))
2227         b = append(b, v...)
2228         return b, nil
2229 }
2230 func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2231         v := *ptr.toString()
2232         if v == "" {
2233                 return b, nil
2234         }
2235         b = appendVarint(b, wiretag)
2236         b = appendVarint(b, uint64(len(v)))
2237         b = append(b, v...)
2238         return b, nil
2239 }
2240 func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2241         p := *ptr.toStringPtr()
2242         if p == nil {
2243                 return b, nil
2244         }
2245         v := *p
2246         b = appendVarint(b, wiretag)
2247         b = appendVarint(b, uint64(len(v)))
2248         b = append(b, v...)
2249         return b, nil
2250 }
2251 func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2252         s := *ptr.toStringSlice()
2253         for _, v := range s {
2254                 b = appendVarint(b, wiretag)
2255                 b = appendVarint(b, uint64(len(v)))
2256                 b = append(b, v...)
2257         }
2258         return b, nil
2259 }
2260 func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2261         var invalidUTF8 bool
2262         v := *ptr.toString()
2263         if !utf8.ValidString(v) {
2264                 invalidUTF8 = true
2265         }
2266         b = appendVarint(b, wiretag)
2267         b = appendVarint(b, uint64(len(v)))
2268         b = append(b, v...)
2269         if invalidUTF8 {
2270                 return b, errInvalidUTF8
2271         }
2272         return b, nil
2273 }
2274 func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2275         var invalidUTF8 bool
2276         v := *ptr.toString()
2277         if v == "" {
2278                 return b, nil
2279         }
2280         if !utf8.ValidString(v) {
2281                 invalidUTF8 = true
2282         }
2283         b = appendVarint(b, wiretag)
2284         b = appendVarint(b, uint64(len(v)))
2285         b = append(b, v...)
2286         if invalidUTF8 {
2287                 return b, errInvalidUTF8
2288         }
2289         return b, nil
2290 }
2291 func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2292         var invalidUTF8 bool
2293         p := *ptr.toStringPtr()
2294         if p == nil {
2295                 return b, nil
2296         }
2297         v := *p
2298         if !utf8.ValidString(v) {
2299                 invalidUTF8 = true
2300         }
2301         b = appendVarint(b, wiretag)
2302         b = appendVarint(b, uint64(len(v)))
2303         b = append(b, v...)
2304         if invalidUTF8 {
2305                 return b, errInvalidUTF8
2306         }
2307         return b, nil
2308 }
2309 func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2310         var invalidUTF8 bool
2311         s := *ptr.toStringSlice()
2312         for _, v := range s {
2313                 if !utf8.ValidString(v) {
2314                         invalidUTF8 = true
2315                 }
2316                 b = appendVarint(b, wiretag)
2317                 b = appendVarint(b, uint64(len(v)))
2318                 b = append(b, v...)
2319         }
2320         if invalidUTF8 {
2321                 return b, errInvalidUTF8
2322         }
2323         return b, nil
2324 }
2325 func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2326         v := *ptr.toBytes()
2327         if v == nil {
2328                 return b, nil
2329         }
2330         b = appendVarint(b, wiretag)
2331         b = appendVarint(b, uint64(len(v)))
2332         b = append(b, v...)
2333         return b, nil
2334 }
2335 func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2336         v := *ptr.toBytes()
2337         if len(v) == 0 {
2338                 return b, nil
2339         }
2340         b = appendVarint(b, wiretag)
2341         b = appendVarint(b, uint64(len(v)))
2342         b = append(b, v...)
2343         return b, nil
2344 }
2345 func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2346         v := *ptr.toBytes()
2347         b = appendVarint(b, wiretag)
2348         b = appendVarint(b, uint64(len(v)))
2349         b = append(b, v...)
2350         return b, nil
2351 }
2352 func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2353         s := *ptr.toBytesSlice()
2354         for _, v := range s {
2355                 b = appendVarint(b, wiretag)
2356                 b = appendVarint(b, uint64(len(v)))
2357                 b = append(b, v...)
2358         }
2359         return b, nil
2360 }
2361
2362 // makeGroupMarshaler returns the sizer and marshaler for a group.
2363 // u is the marshal info of the underlying message.
2364 func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
2365         return func(ptr pointer, tagsize int) int {
2366                         p := ptr.getPointer()
2367                         if p.isNil() {
2368                                 return 0
2369                         }
2370                         return u.size(p) + 2*tagsize
2371                 },
2372                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2373                         p := ptr.getPointer()
2374                         if p.isNil() {
2375                                 return b, nil
2376                         }
2377                         var err error
2378                         b = appendVarint(b, wiretag) // start group
2379                         b, err = u.marshal(b, p, deterministic)
2380                         b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2381                         return b, err
2382                 }
2383 }
2384
2385 // makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
2386 // u is the marshal info of the underlying message.
2387 func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2388         return func(ptr pointer, tagsize int) int {
2389                         s := ptr.getPointerSlice()
2390                         n := 0
2391                         for _, v := range s {
2392                                 if v.isNil() {
2393                                         continue
2394                                 }
2395                                 n += u.size(v) + 2*tagsize
2396                         }
2397                         return n
2398                 },
2399                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2400                         s := ptr.getPointerSlice()
2401                         var err error
2402                         var nerr nonFatal
2403                         for _, v := range s {
2404                                 if v.isNil() {
2405                                         return b, errRepeatedHasNil
2406                                 }
2407                                 b = appendVarint(b, wiretag) // start group
2408                                 b, err = u.marshal(b, v, deterministic)
2409                                 b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2410                                 if !nerr.Merge(err) {
2411                                         if err == ErrNil {
2412                                                 err = errRepeatedHasNil
2413                                         }
2414                                         return b, err
2415                                 }
2416                         }
2417                         return b, nerr.E
2418                 }
2419 }
2420
2421 // makeMessageMarshaler returns the sizer and marshaler for a message field.
2422 // u is the marshal info of the message.
2423 func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
2424         return func(ptr pointer, tagsize int) int {
2425                         p := ptr.getPointer()
2426                         if p.isNil() {
2427                                 return 0
2428                         }
2429                         siz := u.size(p)
2430                         return siz + SizeVarint(uint64(siz)) + tagsize
2431                 },
2432                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2433                         p := ptr.getPointer()
2434                         if p.isNil() {
2435                                 return b, nil
2436                         }
2437                         b = appendVarint(b, wiretag)
2438                         siz := u.cachedsize(p)
2439                         b = appendVarint(b, uint64(siz))
2440                         return u.marshal(b, p, deterministic)
2441                 }
2442 }
2443
2444 // makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
2445 // u is the marshal info of the message.
2446 func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2447         return func(ptr pointer, tagsize int) int {
2448                         s := ptr.getPointerSlice()
2449                         n := 0
2450                         for _, v := range s {
2451                                 if v.isNil() {
2452                                         continue
2453                                 }
2454                                 siz := u.size(v)
2455                                 n += siz + SizeVarint(uint64(siz)) + tagsize
2456                         }
2457                         return n
2458                 },
2459                 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2460                         s := ptr.getPointerSlice()
2461                         var err error
2462                         var nerr nonFatal
2463                         for _, v := range s {
2464                                 if v.isNil() {
2465                                         return b, errRepeatedHasNil
2466                                 }
2467                                 b = appendVarint(b, wiretag)
2468                                 siz := u.cachedsize(v)
2469                                 b = appendVarint(b, uint64(siz))
2470                                 b, err = u.marshal(b, v, deterministic)
2471
2472                                 if !nerr.Merge(err) {
2473                                         if err == ErrNil {
2474                                                 err = errRepeatedHasNil
2475                                         }
2476                                         return b, err
2477                                 }
2478                         }
2479                         return b, nerr.E
2480                 }
2481 }
2482
2483 // makeMapMarshaler returns the sizer and marshaler for a map field.
2484 // f is the pointer to the reflect data structure of the field.
2485 func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
2486         // figure out key and value type
2487         t := f.Type
2488         keyType := t.Key()
2489         valType := t.Elem()
2490         tags := strings.Split(f.Tag.Get("protobuf"), ",")
2491         keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
2492         valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
2493         stdOptions := false
2494         for _, t := range tags {
2495                 if strings.HasPrefix(t, "customtype=") {
2496                         valTags = append(valTags, t)
2497                 }
2498                 if t == "stdtime" {
2499                         valTags = append(valTags, t)
2500                         stdOptions = true
2501                 }
2502                 if t == "stdduration" {
2503                         valTags = append(valTags, t)
2504                         stdOptions = true
2505                 }
2506                 if t == "wktptr" {
2507                         valTags = append(valTags, t)
2508                 }
2509         }
2510         keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
2511         valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
2512         keyWireTag := 1<<3 | wiretype(keyTags[0])
2513         valWireTag := 2<<3 | wiretype(valTags[0])
2514
2515         // We create an interface to get the addresses of the map key and value.
2516         // If value is pointer-typed, the interface is a direct interface, the
2517         // idata itself is the value. Otherwise, the idata is the pointer to the
2518         // value.
2519         // Key cannot be pointer-typed.
2520         valIsPtr := valType.Kind() == reflect.Ptr
2521
2522         // If value is a message with nested maps, calling
2523         // valSizer in marshal may be quadratic. We should use
2524         // cached version in marshal (but not in size).
2525         // If value is not message type, we don't have size cache,
2526         // but it cannot be nested either. Just use valSizer.
2527         valCachedSizer := valSizer
2528         if valIsPtr && !stdOptions && valType.Elem().Kind() == reflect.Struct {
2529                 u := getMarshalInfo(valType.Elem())
2530                 valCachedSizer = func(ptr pointer, tagsize int) int {
2531                         // Same as message sizer, but use cache.
2532                         p := ptr.getPointer()
2533                         if p.isNil() {
2534                                 return 0
2535                         }
2536                         siz := u.cachedsize(p)
2537                         return siz + SizeVarint(uint64(siz)) + tagsize
2538                 }
2539         }
2540         return func(ptr pointer, tagsize int) int {
2541                         m := ptr.asPointerTo(t).Elem() // the map
2542                         n := 0
2543                         for _, k := range m.MapKeys() {
2544                                 ki := k.Interface()
2545                                 vi := m.MapIndex(k).Interface()
2546                                 kaddr := toAddrPointer(&ki, false)             // pointer to key
2547                                 vaddr := toAddrPointer(&vi, valIsPtr)          // pointer to value
2548                                 siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2549                                 n += siz + SizeVarint(uint64(siz)) + tagsize
2550                         }
2551                         return n
2552                 },
2553                 func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
2554                         m := ptr.asPointerTo(t).Elem() // the map
2555                         var err error
2556                         keys := m.MapKeys()
2557                         if len(keys) > 1 && deterministic {
2558                                 sort.Sort(mapKeys(keys))
2559                         }
2560
2561                         var nerr nonFatal
2562                         for _, k := range keys {
2563                                 ki := k.Interface()
2564                                 vi := m.MapIndex(k).Interface()
2565                                 kaddr := toAddrPointer(&ki, false)    // pointer to key
2566                                 vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
2567                                 b = appendVarint(b, tag)
2568                                 siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2569                                 b = appendVarint(b, uint64(siz))
2570                                 b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
2571                                 if !nerr.Merge(err) {
2572                                         return b, err
2573                                 }
2574                                 b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
2575                                 if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
2576                                         return b, err
2577                                 }
2578                         }
2579                         return b, nerr.E
2580                 }
2581 }
2582
2583 // makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
2584 // fi is the marshal info of the field.
2585 // f is the pointer to the reflect data structure of the field.
2586 func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
2587         // Oneof field is an interface. We need to get the actual data type on the fly.
2588         t := f.Type
2589         return func(ptr pointer, _ int) int {
2590                         p := ptr.getInterfacePointer()
2591                         if p.isNil() {
2592                                 return 0
2593                         }
2594                         v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2595                         telem := v.Type()
2596                         e := fi.oneofElems[telem]
2597                         return e.sizer(p, e.tagsize)
2598                 },
2599                 func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
2600                         p := ptr.getInterfacePointer()
2601                         if p.isNil() {
2602                                 return b, nil
2603                         }
2604                         v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2605                         telem := v.Type()
2606                         if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
2607                                 return b, errOneofHasNil
2608                         }
2609                         e := fi.oneofElems[telem]
2610                         return e.marshaler(b, p, e.wiretag, deterministic)
2611                 }
2612 }
2613
2614 // sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
2615 func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
2616         m, mu := ext.extensionsRead()
2617         if m == nil {
2618                 return 0
2619         }
2620         mu.Lock()
2621
2622         n := 0
2623         for _, e := range m {
2624                 if e.value == nil || e.desc == nil {
2625                         // Extension is only in its encoded form.
2626                         n += len(e.enc)
2627                         continue
2628                 }
2629
2630                 // We don't skip extensions that have an encoded form set,
2631                 // because the extension value may have been mutated after
2632                 // the last time this function was called.
2633                 ei := u.getExtElemInfo(e.desc)
2634                 v := e.value
2635                 p := toAddrPointer(&v, ei.isptr)
2636                 n += ei.sizer(p, ei.tagsize)
2637         }
2638         mu.Unlock()
2639         return n
2640 }
2641
2642 // appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
2643 func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2644         m, mu := ext.extensionsRead()
2645         if m == nil {
2646                 return b, nil
2647         }
2648         mu.Lock()
2649         defer mu.Unlock()
2650
2651         var err error
2652         var nerr nonFatal
2653
2654         // Fast-path for common cases: zero or one extensions.
2655         // Don't bother sorting the keys.
2656         if len(m) <= 1 {
2657                 for _, e := range m {
2658                         if e.value == nil || e.desc == nil {
2659                                 // Extension is only in its encoded form.
2660                                 b = append(b, e.enc...)
2661                                 continue
2662                         }
2663
2664                         // We don't skip extensions that have an encoded form set,
2665                         // because the extension value may have been mutated after
2666                         // the last time this function was called.
2667
2668                         ei := u.getExtElemInfo(e.desc)
2669                         v := e.value
2670                         p := toAddrPointer(&v, ei.isptr)
2671                         b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2672                         if !nerr.Merge(err) {
2673                                 return b, err
2674                         }
2675                 }
2676                 return b, nerr.E
2677         }
2678
2679         // Sort the keys to provide a deterministic encoding.
2680         // Not sure this is required, but the old code does it.
2681         keys := make([]int, 0, len(m))
2682         for k := range m {
2683                 keys = append(keys, int(k))
2684         }
2685         sort.Ints(keys)
2686
2687         for _, k := range keys {
2688                 e := m[int32(k)]
2689                 if e.value == nil || e.desc == nil {
2690                         // Extension is only in its encoded form.
2691                         b = append(b, e.enc...)
2692                         continue
2693                 }
2694
2695                 // We don't skip extensions that have an encoded form set,
2696                 // because the extension value may have been mutated after
2697                 // the last time this function was called.
2698
2699                 ei := u.getExtElemInfo(e.desc)
2700                 v := e.value
2701                 p := toAddrPointer(&v, ei.isptr)
2702                 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2703                 if !nerr.Merge(err) {
2704                         return b, err
2705                 }
2706         }
2707         return b, nerr.E
2708 }
2709
2710 // message set format is:
2711 //   message MessageSet {
2712 //     repeated group Item = 1 {
2713 //       required int32 type_id = 2;
2714 //       required string message = 3;
2715 //     };
2716 //   }
2717
2718 // sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
2719 // in message set format (above).
2720 func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
2721         m, mu := ext.extensionsRead()
2722         if m == nil {
2723                 return 0
2724         }
2725         mu.Lock()
2726
2727         n := 0
2728         for id, e := range m {
2729                 n += 2                          // start group, end group. tag = 1 (size=1)
2730                 n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
2731
2732                 if e.value == nil || e.desc == nil {
2733                         // Extension is only in its encoded form.
2734                         msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2735                         siz := len(msgWithLen)
2736                         n += siz + 1 // message, tag = 3 (size=1)
2737                         continue
2738                 }
2739
2740                 // We don't skip extensions that have an encoded form set,
2741                 // because the extension value may have been mutated after
2742                 // the last time this function was called.
2743
2744                 ei := u.getExtElemInfo(e.desc)
2745                 v := e.value
2746                 p := toAddrPointer(&v, ei.isptr)
2747                 n += ei.sizer(p, 1) // message, tag = 3 (size=1)
2748         }
2749         mu.Unlock()
2750         return n
2751 }
2752
2753 // appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
2754 // to the end of byte slice b.
2755 func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2756         m, mu := ext.extensionsRead()
2757         if m == nil {
2758                 return b, nil
2759         }
2760         mu.Lock()
2761         defer mu.Unlock()
2762
2763         var err error
2764         var nerr nonFatal
2765
2766         // Fast-path for common cases: zero or one extensions.
2767         // Don't bother sorting the keys.
2768         if len(m) <= 1 {
2769                 for id, e := range m {
2770                         b = append(b, 1<<3|WireStartGroup)
2771                         b = append(b, 2<<3|WireVarint)
2772                         b = appendVarint(b, uint64(id))
2773
2774                         if e.value == nil || e.desc == nil {
2775                                 // Extension is only in its encoded form.
2776                                 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2777                                 b = append(b, 3<<3|WireBytes)
2778                                 b = append(b, msgWithLen...)
2779                                 b = append(b, 1<<3|WireEndGroup)
2780                                 continue
2781                         }
2782
2783                         // We don't skip extensions that have an encoded form set,
2784                         // because the extension value may have been mutated after
2785                         // the last time this function was called.
2786
2787                         ei := u.getExtElemInfo(e.desc)
2788                         v := e.value
2789                         p := toAddrPointer(&v, ei.isptr)
2790                         b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2791                         if !nerr.Merge(err) {
2792                                 return b, err
2793                         }
2794                         b = append(b, 1<<3|WireEndGroup)
2795                 }
2796                 return b, nerr.E
2797         }
2798
2799         // Sort the keys to provide a deterministic encoding.
2800         keys := make([]int, 0, len(m))
2801         for k := range m {
2802                 keys = append(keys, int(k))
2803         }
2804         sort.Ints(keys)
2805
2806         for _, id := range keys {
2807                 e := m[int32(id)]
2808                 b = append(b, 1<<3|WireStartGroup)
2809                 b = append(b, 2<<3|WireVarint)
2810                 b = appendVarint(b, uint64(id))
2811
2812                 if e.value == nil || e.desc == nil {
2813                         // Extension is only in its encoded form.
2814                         msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2815                         b = append(b, 3<<3|WireBytes)
2816                         b = append(b, msgWithLen...)
2817                         b = append(b, 1<<3|WireEndGroup)
2818                         continue
2819                 }
2820
2821                 // We don't skip extensions that have an encoded form set,
2822                 // because the extension value may have been mutated after
2823                 // the last time this function was called.
2824
2825                 ei := u.getExtElemInfo(e.desc)
2826                 v := e.value
2827                 p := toAddrPointer(&v, ei.isptr)
2828                 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2829                 b = append(b, 1<<3|WireEndGroup)
2830                 if !nerr.Merge(err) {
2831                         return b, err
2832                 }
2833         }
2834         return b, nerr.E
2835 }
2836
2837 // sizeV1Extensions computes the size of encoded data for a V1-API extension field.
2838 func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
2839         if m == nil {
2840                 return 0
2841         }
2842
2843         n := 0
2844         for _, e := range m {
2845                 if e.value == nil || e.desc == nil {
2846                         // Extension is only in its encoded form.
2847                         n += len(e.enc)
2848                         continue
2849                 }
2850
2851                 // We don't skip extensions that have an encoded form set,
2852                 // because the extension value may have been mutated after
2853                 // the last time this function was called.
2854
2855                 ei := u.getExtElemInfo(e.desc)
2856                 v := e.value
2857                 p := toAddrPointer(&v, ei.isptr)
2858                 n += ei.sizer(p, ei.tagsize)
2859         }
2860         return n
2861 }
2862
2863 // appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
2864 func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
2865         if m == nil {
2866                 return b, nil
2867         }
2868
2869         // Sort the keys to provide a deterministic encoding.
2870         keys := make([]int, 0, len(m))
2871         for k := range m {
2872                 keys = append(keys, int(k))
2873         }
2874         sort.Ints(keys)
2875
2876         var err error
2877         var nerr nonFatal
2878         for _, k := range keys {
2879                 e := m[int32(k)]
2880                 if e.value == nil || e.desc == nil {
2881                         // Extension is only in its encoded form.
2882                         b = append(b, e.enc...)
2883                         continue
2884                 }
2885
2886                 // We don't skip extensions that have an encoded form set,
2887                 // because the extension value may have been mutated after
2888                 // the last time this function was called.
2889
2890                 ei := u.getExtElemInfo(e.desc)
2891                 v := e.value
2892                 p := toAddrPointer(&v, ei.isptr)
2893                 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2894                 if !nerr.Merge(err) {
2895                         return b, err
2896                 }
2897         }
2898         return b, nerr.E
2899 }
2900
2901 // newMarshaler is the interface representing objects that can marshal themselves.
2902 //
2903 // This exists to support protoc-gen-go generated messages.
2904 // The proto package will stop type-asserting to this interface in the future.
2905 //
2906 // DO NOT DEPEND ON THIS.
2907 type newMarshaler interface {
2908         XXX_Size() int
2909         XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
2910 }
2911
2912 // Size returns the encoded size of a protocol buffer message.
2913 // This is the main entry point.
2914 func Size(pb Message) int {
2915         if m, ok := pb.(newMarshaler); ok {
2916                 return m.XXX_Size()
2917         }
2918         if m, ok := pb.(Marshaler); ok {
2919                 // If the message can marshal itself, let it do it, for compatibility.
2920                 // NOTE: This is not efficient.
2921                 b, _ := m.Marshal()
2922                 return len(b)
2923         }
2924         // in case somehow we didn't generate the wrapper
2925         if pb == nil {
2926                 return 0
2927         }
2928         var info InternalMessageInfo
2929         return info.Size(pb)
2930 }
2931
2932 // Marshal takes a protocol buffer message
2933 // and encodes it into the wire format, returning the data.
2934 // This is the main entry point.
2935 func Marshal(pb Message) ([]byte, error) {
2936         if m, ok := pb.(newMarshaler); ok {
2937                 siz := m.XXX_Size()
2938                 b := make([]byte, 0, siz)
2939                 return m.XXX_Marshal(b, false)
2940         }
2941         if m, ok := pb.(Marshaler); ok {
2942                 // If the message can marshal itself, let it do it, for compatibility.
2943                 // NOTE: This is not efficient.
2944                 return m.Marshal()
2945         }
2946         // in case somehow we didn't generate the wrapper
2947         if pb == nil {
2948                 return nil, ErrNil
2949         }
2950         var info InternalMessageInfo
2951         siz := info.Size(pb)
2952         b := make([]byte, 0, siz)
2953         return info.Marshal(b, pb, false)
2954 }
2955
2956 // Marshal takes a protocol buffer message
2957 // and encodes it into the wire format, writing the result to the
2958 // Buffer.
2959 // This is an alternative entry point. It is not necessary to use
2960 // a Buffer for most applications.
2961 func (p *Buffer) Marshal(pb Message) error {
2962         var err error
2963         if p.deterministic {
2964                 if _, ok := pb.(Marshaler); ok {
2965                         return fmt.Errorf("proto: deterministic not supported by the Marshal method of %T", pb)
2966                 }
2967         }
2968         if m, ok := pb.(newMarshaler); ok {
2969                 siz := m.XXX_Size()
2970                 p.grow(siz) // make sure buf has enough capacity
2971                 p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
2972                 return err
2973         }
2974         if m, ok := pb.(Marshaler); ok {
2975                 // If the message can marshal itself, let it do it, for compatibility.
2976                 // NOTE: This is not efficient.
2977                 var b []byte
2978                 b, err = m.Marshal()
2979                 p.buf = append(p.buf, b...)
2980                 return err
2981         }
2982         // in case somehow we didn't generate the wrapper
2983         if pb == nil {
2984                 return ErrNil
2985         }
2986         var info InternalMessageInfo
2987         siz := info.Size(pb)
2988         p.grow(siz) // make sure buf has enough capacity
2989         p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
2990         return err
2991 }
2992
2993 // grow grows the buffer's capacity, if necessary, to guarantee space for
2994 // another n bytes. After grow(n), at least n bytes can be written to the
2995 // buffer without another allocation.
2996 func (p *Buffer) grow(n int) {
2997         need := len(p.buf) + n
2998         if need <= cap(p.buf) {
2999                 return
3000         }
3001         newCap := len(p.buf) * 2
3002         if newCap < need {
3003                 newCap = need
3004         }
3005         p.buf = append(make([]byte, 0, newCap), p.buf...)
3006 }