blob: 7356b323fdc3b2220f1687d4fb7c7dc5e6edcc70 [file] [log] [blame]
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package fileinit
import (
"bytes"
"fmt"
"reflect"
defval "github.com/golang/protobuf/v2/internal/encoding/defval"
wire "github.com/golang/protobuf/v2/internal/encoding/wire"
fieldnum "github.com/golang/protobuf/v2/internal/fieldnum"
pimpl "github.com/golang/protobuf/v2/internal/impl"
ptype "github.com/golang/protobuf/v2/internal/prototype"
pvalue "github.com/golang/protobuf/v2/internal/value"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
)
func (file *fileDesc) lazyInit() *fileLazy {
file.once.Do(func() {
file.unmarshalFull(file.RawDescriptor)
file.resolveImports()
file.resolveEnums()
file.resolveMessages()
file.resolveExtensions()
file.resolveServices()
file.finishInit()
})
return file.lazy
}
func (file *fileDesc) resolveImports() {
// TODO: Resolve file dependencies.
}
func (file *fileDesc) resolveEnums() {
enumDecls := file.GoTypes[:len(file.allEnums)]
for i := range file.allEnums {
ed := &file.allEnums[i]
// Associate the EnumType with a concrete Go type.
enumCache := map[pref.EnumNumber]pref.Enum{}
ed.lazy.typ = reflect.TypeOf(enumDecls[i])
ed.lazy.new = func(n pref.EnumNumber) pref.Enum {
if v, ok := enumCache[n]; ok {
return v
}
v := reflect.New(ed.lazy.typ).Elem()
v.SetInt(int64(n))
return v.Interface().(pref.Enum)
}
for i := range ed.lazy.values.list {
n := ed.lazy.values.list[i].number
enumCache[n] = ed.lazy.new(n)
}
}
}
func (file *fileDesc) resolveMessages() {
messageDecls := file.GoTypes[len(file.allEnums):]
for i := range file.allMessages {
md := &file.allMessages[i]
// Associate the MessageType with a concrete Go type.
if !md.isMapEntry {
md.lazy.typ = reflect.TypeOf(messageDecls[i])
md.lazy.new = func() pref.Message {
t := md.lazy.typ.Elem()
return reflect.New(t).Interface().(pref.ProtoMessage).ProtoReflect()
}
}
// Resolve message field dependencies.
for j := range md.lazy.fields.list {
fd := &md.lazy.fields.list[j]
if fd.isWeak {
continue
}
switch fd.kind {
case pref.EnumKind:
fd.enumType = file.popEnumDependency()
case pref.MessageKind, pref.GroupKind:
fd.messageType = file.popMessageDependency()
}
fd.isMap = file.isMapEntry(fd.messageType)
if !fd.hasPacked && file.lazy.syntax != pref.Proto2 && fd.cardinality == pref.Repeated {
switch fd.kind {
case pref.StringKind, pref.BytesKind, pref.MessageKind, pref.GroupKind:
fd.isPacked = false
default:
fd.isPacked = true
}
}
fd.defVal.lazyInit(fd.kind, file.enumValuesOf(fd.enumType))
}
}
}
func (file *fileDesc) resolveExtensions() {
for i := range file.allExtensions {
xd := &file.allExtensions[i]
// Associate the ExtensionType with a concrete Go type.
var typ reflect.Type
switch xd.lazy.kind {
case pref.EnumKind, pref.MessageKind, pref.GroupKind:
typ = reflect.TypeOf(file.GoTypes[file.DependencyIndexes[0]])
default:
typ = goTypeForPBKind[xd.lazy.kind]
}
switch xd.lazy.cardinality {
case pref.Optional:
switch xd.lazy.kind {
case pref.EnumKind:
xd.lazy.typ = typ
xd.lazy.new = func() pref.Value {
return xd.lazy.defVal.get()
}
xd.lazy.valueOf = func(v interface{}) pref.Value {
ev := v.(pref.Enum)
return pref.ValueOf(ev.Number())
}
xd.lazy.interfaceOf = func(pv pref.Value) interface{} {
return xd.lazy.enumType.New(pv.Enum())
}
case pref.MessageKind, pref.GroupKind:
xd.lazy.typ = typ
xd.lazy.new = func() pref.Value {
return pref.ValueOf(xd.lazy.messageType.New())
}
xd.lazy.valueOf = func(v interface{}) pref.Value {
mv := v.(pref.ProtoMessage).ProtoReflect()
return pref.ValueOf(mv)
}
xd.lazy.interfaceOf = func(pv pref.Value) interface{} {
return pv.Message().Interface()
}
default:
xd.lazy.typ = goTypeForPBKind[xd.lazy.kind]
xd.lazy.new = func() pref.Value {
return xd.lazy.defVal.get()
}
xd.lazy.valueOf = func(v interface{}) pref.Value {
return pref.ValueOf(v)
}
xd.lazy.interfaceOf = func(pv pref.Value) interface{} {
return pv.Interface()
}
}
case pref.Repeated:
c := pvalue.NewConverter(typ, xd.lazy.kind)
xd.lazy.typ = reflect.PtrTo(reflect.SliceOf(typ))
xd.lazy.new = func() pref.Value {
v := reflect.New(xd.lazy.typ.Elem()).Interface()
return pref.ValueOf(pvalue.ListOf(v, c))
}
xd.lazy.valueOf = func(v interface{}) pref.Value {
return pref.ValueOf(pvalue.ListOf(v, c))
}
xd.lazy.interfaceOf = func(pv pref.Value) interface{} {
return pv.List().(pvalue.Unwrapper).ProtoUnwrap()
}
default:
panic(fmt.Sprintf("invalid cardinality: %v", xd.lazy.cardinality))
}
// Resolve extension field dependency.
switch xd.lazy.kind {
case pref.EnumKind:
xd.lazy.enumType = file.popEnumDependency().(pref.EnumType)
case pref.MessageKind, pref.GroupKind:
xd.lazy.messageType = file.popMessageDependency().(pref.MessageType)
}
xd.lazy.defVal.lazyInit(xd.lazy.kind, file.enumValuesOf(xd.lazy.enumType))
}
}
var goTypeForPBKind = map[pref.Kind]reflect.Type{
pref.BoolKind: reflect.TypeOf(bool(false)),
pref.Int32Kind: reflect.TypeOf(int32(0)),
pref.Sint32Kind: reflect.TypeOf(int32(0)),
pref.Sfixed32Kind: reflect.TypeOf(int32(0)),
pref.Int64Kind: reflect.TypeOf(int64(0)),
pref.Sint64Kind: reflect.TypeOf(int64(0)),
pref.Sfixed64Kind: reflect.TypeOf(int64(0)),
pref.Uint32Kind: reflect.TypeOf(uint32(0)),
pref.Fixed32Kind: reflect.TypeOf(uint32(0)),
pref.Uint64Kind: reflect.TypeOf(uint64(0)),
pref.Fixed64Kind: reflect.TypeOf(uint64(0)),
pref.FloatKind: reflect.TypeOf(float32(0)),
pref.DoubleKind: reflect.TypeOf(float64(0)),
pref.StringKind: reflect.TypeOf(string("")),
pref.BytesKind: reflect.TypeOf([]byte(nil)),
}
func (file *fileDesc) resolveServices() {
for i := range file.services.list {
sd := &file.services.list[i]
// Resolve method dependencies.
for j := range sd.lazy.methods.list {
md := &sd.lazy.methods.list[j]
md.inputType = file.popMessageDependency()
md.outputType = file.popMessageDependency()
}
}
}
// isMapEntry reports whether the message is a map entry, being careful to
// avoid calling the IsMapEntry method if the message is declared
// within the same file (which would cause a recursive init deadlock).
func (fd *fileDesc) isMapEntry(md pref.MessageDescriptor) bool {
if md == nil {
return false
}
if md, ok := md.(*messageDescriptor); ok && md.parentFile == fd {
return md.isMapEntry
}
return md.IsMapEntry()
}
// enumValuesOf retrieves the list of enum values for the given enum,
// being careful to avoid calling the Values method if the enum is declared
// within the same file (which would cause a recursive init deadlock).
func (fd *fileDesc) enumValuesOf(ed pref.EnumDescriptor) pref.EnumValueDescriptors {
if ed == nil {
return nil
}
if ed, ok := ed.(*enumDesc); ok && ed.parentFile == fd {
return &ed.lazy.values
}
return ed.Values()
}
func (fd *fileDesc) popEnumDependency() pref.EnumDescriptor {
depIdx := fd.popDependencyIndex()
if depIdx < len(fd.allEnums)+len(fd.allMessages) {
return &fd.allEnums[depIdx]
} else {
return pimpl.Export{}.EnumTypeOf(fd.GoTypes[depIdx])
}
}
func (fd *fileDesc) popMessageDependency() pref.MessageDescriptor {
depIdx := fd.popDependencyIndex()
if depIdx < len(fd.allEnums)+len(fd.allMessages) {
return fd.allMessages[depIdx-len(fd.allEnums)].asDesc()
} else {
return pimpl.Export{}.MessageTypeOf(fd.GoTypes[depIdx])
}
}
func (fi *fileInit) popDependencyIndex() int {
depIdx := fi.DependencyIndexes[0]
fi.DependencyIndexes = fi.DependencyIndexes[1:]
return int(depIdx)
}
func (fi *fileInit) finishInit() {
if len(fi.DependencyIndexes) > 0 {
panic("unused dependencies")
}
*fi = fileInit{} // clear fileInit for GC to reclaim resources
}
type defaultValue struct {
has bool
val pref.Value
enum pref.EnumValueDescriptor
check func() // only set for non-empty bytes
}
func (dv *defaultValue) get() pref.Value {
if dv.check != nil {
dv.check()
}
return dv.val
}
func (dv *defaultValue) lazyInit(k pref.Kind, eds pref.EnumValueDescriptors) {
if dv.has {
switch k {
case pref.EnumKind:
// File descriptors always store default enums by name.
dv.enum = eds.ByName(pref.Name(dv.val.String()))
dv.val = pref.ValueOf(dv.enum.Number())
case pref.BytesKind:
// Store a copy of the default bytes, so that we can detect
// accidental mutations of the original value.
b := append([]byte(nil), dv.val.Bytes()...)
dv.check = func() {
if !bytes.Equal(b, dv.val.Bytes()) {
// TODO: Avoid panic if we're running with the race detector
// and instead spawn a goroutine that periodically resets
// this value back to the original to induce a race.
panic("detected mutation on the default bytes")
}
}
}
} else {
switch k {
case pref.BoolKind:
dv.val = pref.ValueOf(false)
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
dv.val = pref.ValueOf(int32(0))
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
dv.val = pref.ValueOf(int64(0))
case pref.Uint32Kind, pref.Fixed32Kind:
dv.val = pref.ValueOf(uint32(0))
case pref.Uint64Kind, pref.Fixed64Kind:
dv.val = pref.ValueOf(uint64(0))
case pref.FloatKind:
dv.val = pref.ValueOf(float32(0))
case pref.DoubleKind:
dv.val = pref.ValueOf(float64(0))
case pref.StringKind:
dv.val = pref.ValueOf(string(""))
case pref.BytesKind:
dv.val = pref.ValueOf([]byte(nil))
case pref.EnumKind:
dv.enum = eds.Get(0)
dv.val = pref.ValueOf(dv.enum.Number())
}
}
}
func (fd *fileDesc) unmarshalFull(b []byte) {
nb := getNameBuilder()
defer putNameBuilder(nb)
var hasSyntax bool
var enumIdx, messageIdx, extensionIdx, serviceIdx int
fd.lazy = &fileLazy{byName: make(map[pref.FullName]pref.Descriptor)}
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.FileDescriptorProto_PublicDependency:
fd.lazy.imports[v].IsPublic = true
case fieldnum.FileDescriptorProto_WeakDependency:
fd.lazy.imports[v].IsWeak = true
}
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.FileDescriptorProto_Syntax:
hasSyntax = true
switch string(v) {
case "proto2":
fd.lazy.syntax = pref.Proto2
case "proto3":
fd.lazy.syntax = pref.Proto3
default:
panic("invalid syntax")
}
case fieldnum.FileDescriptorProto_Dependency:
fd.lazy.imports = append(fd.lazy.imports, pref.FileImport{
FileDescriptor: ptype.PlaceholderFile(nb.MakeString(v), ""),
})
case fieldnum.FileDescriptorProto_EnumType:
fd.enums.list[enumIdx].unmarshalFull(v, nb)
enumIdx++
case fieldnum.FileDescriptorProto_MessageType:
fd.messages.list[messageIdx].unmarshalFull(v, nb)
messageIdx++
case fieldnum.FileDescriptorProto_Extension:
fd.extensions.list[extensionIdx].unmarshalFull(v, nb)
extensionIdx++
case fieldnum.FileDescriptorProto_Service:
fd.services.list[serviceIdx].unmarshalFull(v, nb)
serviceIdx++
case fieldnum.FileDescriptorProto_Options:
fd.lazy.options = append(fd.lazy.options, v...)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
// If syntax is missing, it is assumed to be proto2.
if !hasSyntax {
fd.lazy.syntax = pref.Proto2
}
}
func (ed *enumDesc) unmarshalFull(b []byte, nb *nameBuilder) {
var rawValues [][]byte
ed.lazy = new(enumLazy)
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.EnumDescriptorProto_Value:
rawValues = append(rawValues, v)
case fieldnum.EnumDescriptorProto_ReservedName:
ed.lazy.resvNames.list = append(ed.lazy.resvNames.list, pref.Name(nb.MakeString(v)))
case fieldnum.EnumDescriptorProto_ReservedRange:
ed.lazy.resvRanges.list = append(ed.lazy.resvRanges.list, unmarshalEnumReservedRange(v))
case fieldnum.EnumDescriptorProto_Options:
ed.lazy.options = append(ed.lazy.options, v...)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if len(rawValues) > 0 {
ed.lazy.values.list = make([]enumValueDesc, len(rawValues))
for i, b := range rawValues {
ed.lazy.values.list[i].unmarshalFull(b, nb, ed.parentFile, ed, i)
}
}
ed.parentFile.lazy.byName[ed.FullName()] = ed
}
func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) {
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.EnumDescriptorProto_EnumReservedRange_Start:
r[0] = pref.EnumNumber(v)
case fieldnum.EnumDescriptorProto_EnumReservedRange_End:
r[1] = pref.EnumNumber(v)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
return r
}
func (vd *enumValueDesc) unmarshalFull(b []byte, nb *nameBuilder, pf *fileDesc, pd pref.Descriptor, i int) {
vd.parentFile = pf
vd.parent = pd
vd.index = i
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.EnumValueDescriptorProto_Number:
vd.number = pref.EnumNumber(v)
}
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.EnumValueDescriptorProto_Name:
vd.fullName = nb.AppendFullName(pd.FullName(), v)
case fieldnum.EnumValueDescriptorProto_Options:
vd.options = append(vd.options, v...)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
vd.parentFile.lazy.byName[vd.FullName()] = vd
}
func (md *messageDesc) unmarshalFull(b []byte, nb *nameBuilder) {
var rawFields, rawOneofs [][]byte
var enumIdx, messageIdx, extensionIdx int
var isMapEntry bool
md.lazy = new(messageLazy)
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.DescriptorProto_Field:
rawFields = append(rawFields, v)
case fieldnum.DescriptorProto_OneofDecl:
rawOneofs = append(rawOneofs, v)
case fieldnum.DescriptorProto_ReservedName:
md.lazy.resvNames.list = append(md.lazy.resvNames.list, pref.Name(nb.MakeString(v)))
case fieldnum.DescriptorProto_ReservedRange:
md.lazy.resvRanges.list = append(md.lazy.resvRanges.list, unmarshalMessageReservedRange(v))
case fieldnum.DescriptorProto_ExtensionRange:
r, opts := unmarshalMessageExtensionRange(v)
md.lazy.extRanges.list = append(md.lazy.extRanges.list, r)
md.lazy.extRangeOptions = append(md.lazy.extRangeOptions, opts)
case fieldnum.DescriptorProto_EnumType:
md.enums.list[enumIdx].unmarshalFull(v, nb)
enumIdx++
case fieldnum.DescriptorProto_NestedType:
md.messages.list[messageIdx].unmarshalFull(v, nb)
messageIdx++
case fieldnum.DescriptorProto_Extension:
md.extensions.list[extensionIdx].unmarshalFull(v, nb)
extensionIdx++
case fieldnum.DescriptorProto_Options:
md.unmarshalOptions(v, &isMapEntry)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if len(rawFields) > 0 || len(rawOneofs) > 0 {
md.lazy.fields.list = make([]fieldDesc, len(rawFields))
md.lazy.oneofs.list = make([]oneofDesc, len(rawOneofs))
for i, b := range rawFields {
fd := &md.lazy.fields.list[i]
fd.unmarshalFull(b, nb, md.parentFile, md.asDesc(), i)
if fd.cardinality == pref.Required {
md.lazy.reqNumbers.list = append(md.lazy.reqNumbers.list, fd.number)
}
}
for i, b := range rawOneofs {
od := &md.lazy.oneofs.list[i]
od.unmarshalFull(b, nb, md.parentFile, md.asDesc(), i)
}
}
if isMapEntry != md.isMapEntry {
panic("mismatching map entry property")
}
md.parentFile.lazy.byName[md.FullName()] = md.asDesc()
}
func (md *messageDesc) unmarshalOptions(b []byte, isMapEntry *bool) {
md.lazy.options = append(md.lazy.options, b...)
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.MessageOptions_MapEntry:
*isMapEntry = wire.DecodeBool(v)
case fieldnum.MessageOptions_MessageSetWireFormat:
md.lazy.isMessageSet = wire.DecodeBool(v)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) {
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.DescriptorProto_ReservedRange_Start:
r[0] = pref.FieldNumber(v)
case fieldnum.DescriptorProto_ReservedRange_End:
r[1] = pref.FieldNumber(v)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
return r
}
func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, opts []byte) {
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.DescriptorProto_ExtensionRange_Start:
r[0] = pref.FieldNumber(v)
case fieldnum.DescriptorProto_ExtensionRange_End:
r[1] = pref.FieldNumber(v)
}
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.DescriptorProto_ExtensionRange_Options:
opts = append(opts, v...)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
return r, opts
}
func (fd *fieldDesc) unmarshalFull(b []byte, nb *nameBuilder, pf *fileDesc, pd pref.Descriptor, i int) {
fd.parentFile = pf
fd.parent = pd
fd.index = i
var rawDefVal []byte
var rawTypeName []byte
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.FieldDescriptorProto_Number:
fd.number = pref.FieldNumber(v)
case fieldnum.FieldDescriptorProto_Label:
fd.cardinality = pref.Cardinality(v)
case fieldnum.FieldDescriptorProto_Type:
fd.kind = pref.Kind(v)
case fieldnum.FieldDescriptorProto_OneofIndex:
// In messageDesc.UnmarshalFull, we allocate slices for both
// the field and oneof descriptors before unmarshaling either
// of them. This ensures pointers to slice elements are stable.
od := &pd.(messageType).lazy.oneofs.list[v]
od.fields.list = append(od.fields.list, fd)
if fd.oneofType != nil {
panic("oneof type already set")
}
fd.oneofType = od
}
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.FieldDescriptorProto_Name:
fd.fullName = nb.AppendFullName(pd.FullName(), v)
case fieldnum.FieldDescriptorProto_JsonName:
fd.hasJSONName = true
fd.jsonName = nb.MakeString(v)
case fieldnum.FieldDescriptorProto_DefaultValue:
fd.defVal.has = true
rawDefVal = v
case fieldnum.FieldDescriptorProto_TypeName:
rawTypeName = v
case fieldnum.FieldDescriptorProto_Options:
fd.unmarshalOptions(v)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if !fd.hasJSONName {
fd.jsonName = nb.MakeJSONName(fd.Name())
}
if rawDefVal != nil {
var err error
fd.defVal.val, err = defval.Unmarshal(string(rawDefVal), fd.kind, defval.Descriptor)
if err != nil {
panic(err)
}
}
if fd.isWeak {
if len(rawTypeName) == 0 || rawTypeName[0] != '.' {
panic("weak target name must be fully qualified")
}
fd.messageType = ptype.PlaceholderMessage(pref.FullName(rawTypeName[1:]))
}
fd.parentFile.lazy.byName[fd.FullName()] = fd
}
func (fd *fieldDesc) unmarshalOptions(b []byte) {
fd.options = append(fd.options, b...)
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.FieldOptions_Packed:
fd.hasPacked = true
fd.isPacked = wire.DecodeBool(v)
case fieldnum.FieldOptions_Weak:
fd.isWeak = wire.DecodeBool(v)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func (od *oneofDesc) unmarshalFull(b []byte, nb *nameBuilder, pf *fileDesc, pd pref.Descriptor, i int) {
od.parentFile = pf
od.parent = pd
od.index = i
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.OneofDescriptorProto_Name:
od.fullName = nb.AppendFullName(pd.FullName(), v)
case fieldnum.OneofDescriptorProto_Options:
od.options = append(od.options, v...)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
od.parentFile.lazy.byName[od.FullName()] = od
}
func (xd *extensionDesc) unmarshalFull(b []byte, nb *nameBuilder) {
var rawDefVal []byte
xd.lazy = new(extensionLazy)
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.FieldDescriptorProto_Label:
xd.lazy.cardinality = pref.Cardinality(v)
case fieldnum.FieldDescriptorProto_Type:
xd.lazy.kind = pref.Kind(v)
}
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.FieldDescriptorProto_JsonName:
xd.lazy.hasJSONName = true
xd.lazy.jsonName = nb.MakeString(v)
case fieldnum.FieldDescriptorProto_DefaultValue:
xd.lazy.defVal.has = true
rawDefVal = v
case fieldnum.FieldDescriptorProto_Options:
xd.unmarshalOptions(v)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if rawDefVal != nil {
var err error
xd.lazy.defVal.val, err = defval.Unmarshal(string(rawDefVal), xd.lazy.kind, defval.Descriptor)
if err != nil {
panic(err)
}
}
xd.parentFile.lazy.byName[xd.FullName()] = xd
}
func (xd *extensionDesc) unmarshalOptions(b []byte) {
xd.lazy.options = append(xd.lazy.options, b...)
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.FieldOptions_Packed:
xd.lazy.isPacked = wire.DecodeBool(v)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
}
func (sd *serviceDesc) unmarshalFull(b []byte, nb *nameBuilder) {
var rawMethods [][]byte
sd.lazy = new(serviceLazy)
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.ServiceDescriptorProto_Method:
rawMethods = append(rawMethods, v)
case fieldnum.ServiceDescriptorProto_Options:
sd.lazy.options = append(sd.lazy.options, v...)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
if len(rawMethods) > 0 {
sd.lazy.methods.list = make([]methodDesc, len(rawMethods))
for i, b := range rawMethods {
sd.lazy.methods.list[i].unmarshalFull(b, nb, sd.parentFile, sd, i)
}
}
sd.parentFile.lazy.byName[sd.FullName()] = sd
}
func (md *methodDesc) unmarshalFull(b []byte, nb *nameBuilder, pf *fileDesc, pd pref.Descriptor, i int) {
md.parentFile = pf
md.parent = pd
md.index = i
for len(b) > 0 {
num, typ, n := wire.ConsumeTag(b)
b = b[n:]
switch typ {
case wire.VarintType:
v, m := wire.ConsumeVarint(b)
b = b[m:]
switch num {
case fieldnum.MethodDescriptorProto_ClientStreaming:
md.isStreamingClient = wire.DecodeBool(v)
case fieldnum.MethodDescriptorProto_ServerStreaming:
md.isStreamingServer = wire.DecodeBool(v)
}
case wire.BytesType:
v, m := wire.ConsumeBytes(b)
b = b[m:]
switch num {
case fieldnum.MethodDescriptorProto_Name:
md.fullName = nb.AppendFullName(pd.FullName(), v)
case fieldnum.MethodDescriptorProto_Options:
md.options = append(md.options, v...)
}
default:
m := wire.ConsumeFieldValue(num, typ, b)
b = b[m:]
}
}
md.parentFile.lazy.byName[md.FullName()] = md
}