|
@@ -52,23 +52,112 @@ type ExtensionRange struct {
|
|
Start, End int32 // both inclusive
|
|
Start, End int32 // both inclusive
|
|
}
|
|
}
|
|
|
|
|
|
-// extendableProto is an interface implemented by any protocol buffer that may be extended.
|
|
|
|
|
|
+// extendableProto is an interface implemented by any protocol buffer generated by the current
|
|
|
|
+// proto compiler that may be extended.
|
|
type extendableProto interface {
|
|
type extendableProto interface {
|
|
Message
|
|
Message
|
|
ExtensionRangeArray() []ExtensionRange
|
|
ExtensionRangeArray() []ExtensionRange
|
|
|
|
+ extensionsWrite() map[int32]Extension
|
|
|
|
+ extensionsRead() (map[int32]Extension, sync.Locker)
|
|
}
|
|
}
|
|
|
|
|
|
-type extensionsMap interface {
|
|
|
|
- extendableProto
|
|
|
|
|
|
+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
|
|
|
|
+// version of the proto compiler that may be extended.
|
|
|
|
+type extendableProtoV1 interface {
|
|
|
|
+ Message
|
|
|
|
+ ExtensionRangeArray() []ExtensionRange
|
|
ExtensionMap() map[int32]Extension
|
|
ExtensionMap() map[int32]Extension
|
|
}
|
|
}
|
|
|
|
|
|
type extensionsBytes interface {
|
|
type extensionsBytes interface {
|
|
- extendableProto
|
|
|
|
|
|
+ Message
|
|
|
|
+ ExtensionRangeArray() []ExtensionRange
|
|
GetExtensions() *[]byte
|
|
GetExtensions() *[]byte
|
|
}
|
|
}
|
|
|
|
|
|
|
|
+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
|
|
|
|
+type extensionAdapter struct {
|
|
|
|
+ extendableProtoV1
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+func (e extensionAdapter) extensionsWrite() map[int32]Extension {
|
|
|
|
+ return e.ExtensionMap()
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
|
|
|
|
+ return e.ExtensionMap(), notLocker{}
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
|
|
|
|
+type notLocker struct{}
|
|
|
|
+
|
|
|
|
+func (n notLocker) Lock() {}
|
|
|
|
+func (n notLocker) Unlock() {}
|
|
|
|
+
|
|
|
|
+// extendable returns the extendableProto interface for the given generated proto message.
|
|
|
|
+// If the proto message has the old extension format, it returns a wrapper that implements
|
|
|
|
+// the extendableProto interface.
|
|
|
|
+func extendable(p interface{}) (extendableProto, bool) {
|
|
|
|
+ if ep, ok := p.(extendableProto); ok {
|
|
|
|
+ return ep, ok
|
|
|
|
+ }
|
|
|
|
+ if ep, ok := p.(extendableProtoV1); ok {
|
|
|
|
+ return extensionAdapter{ep}, ok
|
|
|
|
+ }
|
|
|
|
+ return nil, false
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+// XXX_InternalExtensions is an internal representation of proto extensions.
|
|
|
|
+//
|
|
|
|
+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
|
|
|
|
+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
|
|
|
|
+//
|
|
|
|
+// The methods of XXX_InternalExtensions are not concurrency safe in general,
|
|
|
|
+// but calls to logically read-only methods such as has and get may be executed concurrently.
|
|
|
|
+type XXX_InternalExtensions struct {
|
|
|
|
+ // The struct must be indirect so that if a user inadvertently copies a
|
|
|
|
+ // generated message and its embedded XXX_InternalExtensions, they
|
|
|
|
+ // avoid the mayhem of a copied mutex.
|
|
|
|
+ //
|
|
|
|
+ // The mutex serializes all logically read-only operations to p.extensionMap.
|
|
|
|
+ // It is up to the client to ensure that write operations to p.extensionMap are
|
|
|
|
+ // mutually exclusive with other accesses.
|
|
|
|
+ p *struct {
|
|
|
|
+ mu sync.Mutex
|
|
|
|
+ extensionMap map[int32]Extension
|
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+// extensionsWrite returns the extension map, creating it on first use.
|
|
|
|
+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
|
|
|
|
+ if e.p == nil {
|
|
|
|
+ e.p = new(struct {
|
|
|
|
+ mu sync.Mutex
|
|
|
|
+ extensionMap map[int32]Extension
|
|
|
|
+ })
|
|
|
|
+ e.p.extensionMap = make(map[int32]Extension)
|
|
|
|
+ }
|
|
|
|
+ return e.p.extensionMap
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+// extensionsRead returns the extensions map for read-only use. It may be nil.
|
|
|
|
+// The caller must hold the returned mutex's lock when accessing Elements within the map.
|
|
|
|
+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
|
|
|
|
+ if e.p == nil {
|
|
|
|
+ return nil, nil
|
|
|
|
+ }
|
|
|
|
+ return e.p.extensionMap, &e.p.mu
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+type extensionRange interface {
|
|
|
|
+ Message
|
|
|
|
+ ExtensionRangeArray() []ExtensionRange
|
|
|
|
+}
|
|
|
|
+
|
|
var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()
|
|
var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()
|
|
|
|
+var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem()
|
|
|
|
+var extendableBytesType = reflect.TypeOf((*extensionsBytes)(nil)).Elem()
|
|
|
|
+var extensionRangeType = reflect.TypeOf((*extensionRange)(nil)).Elem()
|
|
|
|
|
|
// ExtensionDesc represents an extension specification.
|
|
// ExtensionDesc represents an extension specification.
|
|
// Used in generated code from the protocol compiler.
|
|
// Used in generated code from the protocol compiler.
|
|
@@ -101,20 +190,23 @@ type Extension struct {
|
|
}
|
|
}
|
|
|
|
|
|
// SetRawExtension is for testing only.
|
|
// SetRawExtension is for testing only.
|
|
-func SetRawExtension(base extendableProto, id int32, b []byte) {
|
|
|
|
- if ebase, ok := base.(extensionsMap); ok {
|
|
|
|
- ebase.ExtensionMap()[id] = Extension{enc: b}
|
|
|
|
- } else if ebase, ok := base.(extensionsBytes); ok {
|
|
|
|
|
|
+func SetRawExtension(base Message, id int32, b []byte) {
|
|
|
|
+ if ebase, ok := base.(extensionsBytes); ok {
|
|
clearExtension(base, id)
|
|
clearExtension(base, id)
|
|
ext := ebase.GetExtensions()
|
|
ext := ebase.GetExtensions()
|
|
*ext = append(*ext, b...)
|
|
*ext = append(*ext, b...)
|
|
- } else {
|
|
|
|
- panic("unreachable")
|
|
|
|
|
|
+ return
|
|
|
|
+ }
|
|
|
|
+ epb, ok := extendable(base)
|
|
|
|
+ if !ok {
|
|
|
|
+ return
|
|
}
|
|
}
|
|
|
|
+ extmap := epb.extensionsWrite()
|
|
|
|
+ extmap[id] = Extension{enc: b}
|
|
}
|
|
}
|
|
|
|
|
|
// isExtensionField returns true iff the given field number is in an extension range.
|
|
// isExtensionField returns true iff the given field number is in an extension range.
|
|
-func isExtensionField(pb extendableProto, field int32) bool {
|
|
|
|
|
|
+func isExtensionField(pb extensionRange, field int32) bool {
|
|
for _, er := range pb.ExtensionRangeArray() {
|
|
for _, er := range pb.ExtensionRangeArray() {
|
|
if er.Start <= field && field <= er.End {
|
|
if er.Start <= field && field <= er.End {
|
|
return true
|
|
return true
|
|
@@ -125,8 +217,12 @@ func isExtensionField(pb extendableProto, field int32) bool {
|
|
|
|
|
|
// checkExtensionTypes checks that the given extension is valid for pb.
|
|
// checkExtensionTypes checks that the given extension is valid for pb.
|
|
func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
|
|
func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
|
|
|
|
+ var pbi interface{} = pb
|
|
// Check the extended type.
|
|
// Check the extended type.
|
|
- if a, b := reflect.TypeOf(pb), reflect.TypeOf(extension.ExtendedType); a != b {
|
|
|
|
|
|
+ if ea, ok := pbi.(extensionAdapter); ok {
|
|
|
|
+ pbi = ea.extendableProtoV1
|
|
|
|
+ }
|
|
|
|
+ if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
|
|
return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())
|
|
return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())
|
|
}
|
|
}
|
|
// Check the range.
|
|
// Check the range.
|
|
@@ -172,43 +268,57 @@ func extensionProperties(ed *ExtensionDesc) *Properties {
|
|
return prop
|
|
return prop
|
|
}
|
|
}
|
|
|
|
|
|
-// encodeExtensionMap encodes any unmarshaled (unencoded) extensions in m.
|
|
|
|
-func encodeExtensionMap(m map[int32]Extension) error {
|
|
|
|
|
|
+// encode encodes any unmarshaled (unencoded) extensions in e.
|
|
|
|
+func encodeExtensions(e *XXX_InternalExtensions) error {
|
|
|
|
+ m, mu := e.extensionsRead()
|
|
|
|
+ if m == nil {
|
|
|
|
+ return nil // fast path
|
|
|
|
+ }
|
|
|
|
+ mu.Lock()
|
|
|
|
+ defer mu.Unlock()
|
|
|
|
+ return encodeExtensionsMap(m)
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+// encode encodes any unmarshaled (unencoded) extensions in e.
|
|
|
|
+func encodeExtensionsMap(m map[int32]Extension) error {
|
|
for k, e := range m {
|
|
for k, e := range m {
|
|
- err := encodeExtension(&e)
|
|
|
|
- if err != nil {
|
|
|
|
|
|
+ if e.value == nil || e.desc == nil {
|
|
|
|
+ // Extension is only in its encoded form.
|
|
|
|
+ continue
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ // We don't skip extensions that have an encoded form set,
|
|
|
|
+ // because the extension value may have been mutated after
|
|
|
|
+ // the last time this function was called.
|
|
|
|
+
|
|
|
|
+ et := reflect.TypeOf(e.desc.ExtensionType)
|
|
|
|
+ props := extensionProperties(e.desc)
|
|
|
|
+
|
|
|
|
+ p := NewBuffer(nil)
|
|
|
|
+ // If e.value has type T, the encoder expects a *struct{ X T }.
|
|
|
|
+ // Pass a *T with a zero field and hope it all works out.
|
|
|
|
+ x := reflect.New(et)
|
|
|
|
+ x.Elem().Set(reflect.ValueOf(e.value))
|
|
|
|
+ if err := props.enc(p, props, toStructPointer(x)); err != nil {
|
|
return err
|
|
return err
|
|
}
|
|
}
|
|
|
|
+ e.enc = p.buf
|
|
m[k] = e
|
|
m[k] = e
|
|
}
|
|
}
|
|
return nil
|
|
return nil
|
|
}
|
|
}
|
|
|
|
|
|
-func encodeExtension(e *Extension) error {
|
|
|
|
- if e.value == nil || e.desc == nil {
|
|
|
|
- // Extension is only in its encoded form.
|
|
|
|
- return nil
|
|
|
|
- }
|
|
|
|
- // We don't skip extensions that have an encoded form set,
|
|
|
|
- // because the extension value may have been mutated after
|
|
|
|
- // the last time this function was called.
|
|
|
|
-
|
|
|
|
- et := reflect.TypeOf(e.desc.ExtensionType)
|
|
|
|
- props := extensionProperties(e.desc)
|
|
|
|
-
|
|
|
|
- p := NewBuffer(nil)
|
|
|
|
- // If e.value has type T, the encoder expects a *struct{ X T }.
|
|
|
|
- // Pass a *T with a zero field and hope it all works out.
|
|
|
|
- x := reflect.New(et)
|
|
|
|
- x.Elem().Set(reflect.ValueOf(e.value))
|
|
|
|
- if err := props.enc(p, props, toStructPointer(x)); err != nil {
|
|
|
|
- return err
|
|
|
|
|
|
+func extensionsSize(e *XXX_InternalExtensions) (n int) {
|
|
|
|
+ m, mu := e.extensionsRead()
|
|
|
|
+ if m == nil {
|
|
|
|
+ return 0
|
|
}
|
|
}
|
|
- e.enc = p.buf
|
|
|
|
- return nil
|
|
|
|
|
|
+ mu.Lock()
|
|
|
|
+ defer mu.Unlock()
|
|
|
|
+ return extensionsMapSize(m)
|
|
}
|
|
}
|
|
|
|
|
|
-func sizeExtensionMap(m map[int32]Extension) (n int) {
|
|
|
|
|
|
+func extensionsMapSize(m map[int32]Extension) (n int) {
|
|
for _, e := range m {
|
|
for _, e := range m {
|
|
if e.value == nil || e.desc == nil {
|
|
if e.value == nil || e.desc == nil {
|
|
// Extension is only in its encoded form.
|
|
// Extension is only in its encoded form.
|
|
@@ -233,12 +343,8 @@ func sizeExtensionMap(m map[int32]Extension) (n int) {
|
|
}
|
|
}
|
|
|
|
|
|
// HasExtension returns whether the given extension is present in pb.
|
|
// HasExtension returns whether the given extension is present in pb.
|
|
-func HasExtension(pb extendableProto, extension *ExtensionDesc) bool {
|
|
|
|
- // TODO: Check types, field numbers, etc.?
|
|
|
|
- if epb, doki := pb.(extensionsMap); doki {
|
|
|
|
- _, ok := epb.ExtensionMap()[extension.Field]
|
|
|
|
- return ok
|
|
|
|
- } else if epb, doki := pb.(extensionsBytes); doki {
|
|
|
|
|
|
+func HasExtension(pb Message, extension *ExtensionDesc) bool {
|
|
|
|
+ if epb, doki := pb.(extensionsBytes); doki {
|
|
ext := epb.GetExtensions()
|
|
ext := epb.GetExtensions()
|
|
buf := *ext
|
|
buf := *ext
|
|
o := 0
|
|
o := 0
|
|
@@ -258,7 +364,19 @@ func HasExtension(pb extendableProto, extension *ExtensionDesc) bool {
|
|
}
|
|
}
|
|
return false
|
|
return false
|
|
}
|
|
}
|
|
- panic("unreachable")
|
|
|
|
|
|
+ // TODO: Check types, field numbers, etc.?
|
|
|
|
+ epb, ok := extendable(pb)
|
|
|
|
+ if !ok {
|
|
|
|
+ return false
|
|
|
|
+ }
|
|
|
|
+ extmap, mu := epb.extensionsRead()
|
|
|
|
+ if extmap == nil {
|
|
|
|
+ return false
|
|
|
|
+ }
|
|
|
|
+ mu.Lock()
|
|
|
|
+ _, ok = extmap[extension.Field]
|
|
|
|
+ mu.Unlock()
|
|
|
|
+ return ok
|
|
}
|
|
}
|
|
|
|
|
|
func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {
|
|
func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {
|
|
@@ -281,64 +399,32 @@ func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {
|
|
return -1
|
|
return -1
|
|
}
|
|
}
|
|
|
|
|
|
-func clearExtension(pb extendableProto, fieldNum int32) {
|
|
|
|
- if epb, doki := pb.(extensionsMap); doki {
|
|
|
|
- delete(epb.ExtensionMap(), fieldNum)
|
|
|
|
- } else if epb, doki := pb.(extensionsBytes); doki {
|
|
|
|
|
|
+// ClearExtension removes the given extension from pb.
|
|
|
|
+func ClearExtension(pb Message, extension *ExtensionDesc) {
|
|
|
|
+ clearExtension(pb, extension.Field)
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+func clearExtension(pb Message, fieldNum int32) {
|
|
|
|
+ if epb, doki := pb.(extensionsBytes); doki {
|
|
offset := 0
|
|
offset := 0
|
|
for offset != -1 {
|
|
for offset != -1 {
|
|
offset = deleteExtension(epb, fieldNum, offset)
|
|
offset = deleteExtension(epb, fieldNum, offset)
|
|
}
|
|
}
|
|
- } else {
|
|
|
|
- panic("unreachable")
|
|
|
|
|
|
+ return
|
|
|
|
+ }
|
|
|
|
+ epb, ok := extendable(pb)
|
|
|
|
+ if !ok {
|
|
|
|
+ return
|
|
}
|
|
}
|
|
-}
|
|
|
|
-
|
|
|
|
-// ClearExtension removes the given extension from pb.
|
|
|
|
-func ClearExtension(pb extendableProto, extension *ExtensionDesc) {
|
|
|
|
// TODO: Check types, field numbers, etc.?
|
|
// TODO: Check types, field numbers, etc.?
|
|
- clearExtension(pb, extension.Field)
|
|
|
|
|
|
+ extmap := epb.extensionsWrite()
|
|
|
|
+ delete(extmap, fieldNum)
|
|
}
|
|
}
|
|
|
|
|
|
// GetExtension parses and returns the given extension of pb.
|
|
// GetExtension parses and returns the given extension of pb.
|
|
-// If the extension is not present it returns ErrMissingExtension.
|
|
|
|
-func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, error) {
|
|
|
|
- if err := checkExtensionTypes(pb, extension); err != nil {
|
|
|
|
- return nil, err
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- if epb, doki := pb.(extensionsMap); doki {
|
|
|
|
- emap := epb.ExtensionMap()
|
|
|
|
- e, ok := emap[extension.Field]
|
|
|
|
- if !ok {
|
|
|
|
- // defaultExtensionValue returns the default value or
|
|
|
|
- // ErrMissingExtension if there is no default.
|
|
|
|
- return defaultExtensionValue(extension)
|
|
|
|
- }
|
|
|
|
- if e.value != nil {
|
|
|
|
- // Already decoded. Check the descriptor, though.
|
|
|
|
- if e.desc != extension {
|
|
|
|
- // This shouldn't happen. If it does, it means that
|
|
|
|
- // GetExtension was called twice with two different
|
|
|
|
- // descriptors with the same field number.
|
|
|
|
- return nil, errors.New("proto: descriptor conflict")
|
|
|
|
- }
|
|
|
|
- return e.value, nil
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- v, err := decodeExtension(e.enc, extension)
|
|
|
|
- if err != nil {
|
|
|
|
- return nil, err
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- // Remember the decoded version and drop the encoded version.
|
|
|
|
- // That way it is safe to mutate what we return.
|
|
|
|
- e.value = v
|
|
|
|
- e.desc = extension
|
|
|
|
- e.enc = nil
|
|
|
|
- emap[extension.Field] = e
|
|
|
|
- return e.value, nil
|
|
|
|
- } else if epb, doki := pb.(extensionsBytes); doki {
|
|
|
|
|
|
+// If the extension is not present and has no default value it returns ErrMissingExtension.
|
|
|
|
+func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
|
|
|
|
+ if epb, doki := pb.(extensionsBytes); doki {
|
|
ext := epb.GetExtensions()
|
|
ext := epb.GetExtensions()
|
|
o := 0
|
|
o := 0
|
|
for o < len(*ext) {
|
|
for o < len(*ext) {
|
|
@@ -360,7 +446,50 @@ func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, er
|
|
}
|
|
}
|
|
return defaultExtensionValue(extension)
|
|
return defaultExtensionValue(extension)
|
|
}
|
|
}
|
|
- panic("unreachable")
|
|
|
|
|
|
+ epb, ok := extendable(pb)
|
|
|
|
+ if !ok {
|
|
|
|
+ return nil, errors.New("proto: not an extendable proto")
|
|
|
|
+ }
|
|
|
|
+ if err := checkExtensionTypes(epb, extension); err != nil {
|
|
|
|
+ return nil, err
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ emap, mu := epb.extensionsRead()
|
|
|
|
+ if emap == nil {
|
|
|
|
+ return defaultExtensionValue(extension)
|
|
|
|
+ }
|
|
|
|
+ mu.Lock()
|
|
|
|
+ defer mu.Unlock()
|
|
|
|
+ e, ok := emap[extension.Field]
|
|
|
|
+ if !ok {
|
|
|
|
+ // defaultExtensionValue returns the default value or
|
|
|
|
+ // ErrMissingExtension if there is no default.
|
|
|
|
+ return defaultExtensionValue(extension)
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if e.value != nil {
|
|
|
|
+ // Already decoded. Check the descriptor, though.
|
|
|
|
+ if e.desc != extension {
|
|
|
|
+ // This shouldn't happen. If it does, it means that
|
|
|
|
+ // GetExtension was called twice with two different
|
|
|
|
+ // descriptors with the same field number.
|
|
|
|
+ return nil, errors.New("proto: descriptor conflict")
|
|
|
|
+ }
|
|
|
|
+ return e.value, nil
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ v, err := decodeExtension(e.enc, extension)
|
|
|
|
+ if err != nil {
|
|
|
|
+ return nil, err
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ // Remember the decoded version and drop the encoded version.
|
|
|
|
+ // That way it is safe to mutate what we return.
|
|
|
|
+ e.value = v
|
|
|
|
+ e.desc = extension
|
|
|
|
+ e.enc = nil
|
|
|
|
+ emap[extension.Field] = e
|
|
|
|
+ return e.value, nil
|
|
}
|
|
}
|
|
|
|
|
|
// defaultExtensionValue returns the default value for extension.
|
|
// defaultExtensionValue returns the default value for extension.
|
|
@@ -434,14 +563,9 @@ func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
|
|
// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
|
|
// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
|
|
// The returned slice has the same length as es; missing extensions will appear as nil elements.
|
|
// The returned slice has the same length as es; missing extensions will appear as nil elements.
|
|
func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
|
|
func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
|
|
- epb, ok := pb.(extendableProto)
|
|
|
|
- if !ok {
|
|
|
|
- err = errors.New("proto: not an extendable proto")
|
|
|
|
- return
|
|
|
|
- }
|
|
|
|
extensions = make([]interface{}, len(es))
|
|
extensions = make([]interface{}, len(es))
|
|
for i, e := range es {
|
|
for i, e := range es {
|
|
- extensions[i], err = GetExtension(epb, e)
|
|
|
|
|
|
+ extensions[i], err = GetExtension(pb, e)
|
|
if err == ErrMissingExtension {
|
|
if err == ErrMissingExtension {
|
|
err = nil
|
|
err = nil
|
|
}
|
|
}
|
|
@@ -452,9 +576,55 @@ func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, e
|
|
return
|
|
return
|
|
}
|
|
}
|
|
|
|
|
|
|
|
+// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
|
|
|
|
+// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
|
|
|
|
+// just the Field field, which defines the extension's field number.
|
|
|
|
+func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
|
|
|
|
+ epb, ok := extendable(pb)
|
|
|
|
+ if !ok {
|
|
|
|
+ return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb)
|
|
|
|
+ }
|
|
|
|
+ registeredExtensions := RegisteredExtensions(pb)
|
|
|
|
+
|
|
|
|
+ emap, mu := epb.extensionsRead()
|
|
|
|
+ mu.Lock()
|
|
|
|
+ defer mu.Unlock()
|
|
|
|
+ extensions := make([]*ExtensionDesc, 0, len(emap))
|
|
|
|
+ for extid, e := range emap {
|
|
|
|
+ desc := e.desc
|
|
|
|
+ if desc == nil {
|
|
|
|
+ desc = registeredExtensions[extid]
|
|
|
|
+ if desc == nil {
|
|
|
|
+ desc = &ExtensionDesc{Field: extid}
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ extensions = append(extensions, desc)
|
|
|
|
+ }
|
|
|
|
+ return extensions, nil
|
|
|
|
+}
|
|
|
|
+
|
|
// SetExtension sets the specified extension of pb to the specified value.
|
|
// SetExtension sets the specified extension of pb to the specified value.
|
|
-func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error {
|
|
|
|
- if err := checkExtensionTypes(pb, extension); err != nil {
|
|
|
|
|
|
+func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
|
|
|
|
+ if epb, doki := pb.(extensionsBytes); doki {
|
|
|
|
+ ClearExtension(pb, extension)
|
|
|
|
+ ext := epb.GetExtensions()
|
|
|
|
+ et := reflect.TypeOf(extension.ExtensionType)
|
|
|
|
+ props := extensionProperties(extension)
|
|
|
|
+ p := NewBuffer(nil)
|
|
|
|
+ x := reflect.New(et)
|
|
|
|
+ x.Elem().Set(reflect.ValueOf(value))
|
|
|
|
+ if err := props.enc(p, props, toStructPointer(x)); err != nil {
|
|
|
|
+ return err
|
|
|
|
+ }
|
|
|
|
+ *ext = append(*ext, p.buf...)
|
|
|
|
+ return nil
|
|
|
|
+ }
|
|
|
|
+ epb, ok := extendable(pb)
|
|
|
|
+ if !ok {
|
|
|
|
+ return errors.New("proto: not an extendable proto")
|
|
|
|
+ }
|
|
|
|
+ if err := checkExtensionTypes(epb, extension); err != nil {
|
|
return err
|
|
return err
|
|
}
|
|
}
|
|
typ := reflect.TypeOf(extension.ExtensionType)
|
|
typ := reflect.TypeOf(extension.ExtensionType)
|
|
@@ -469,26 +639,27 @@ func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{
|
|
if reflect.ValueOf(value).IsNil() {
|
|
if reflect.ValueOf(value).IsNil() {
|
|
return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
|
|
return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
|
|
}
|
|
}
|
|
- return setExtension(pb, extension, value)
|
|
|
|
|
|
+
|
|
|
|
+ extmap := epb.extensionsWrite()
|
|
|
|
+ extmap[extension.Field] = Extension{desc: extension, value: value}
|
|
|
|
+ return nil
|
|
}
|
|
}
|
|
|
|
|
|
-func setExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error {
|
|
|
|
- if epb, doki := pb.(extensionsMap); doki {
|
|
|
|
- epb.ExtensionMap()[extension.Field] = Extension{desc: extension, value: value}
|
|
|
|
- } else if epb, doki := pb.(extensionsBytes); doki {
|
|
|
|
- ClearExtension(pb, extension)
|
|
|
|
|
|
+// ClearAllExtensions clears all extensions from pb.
|
|
|
|
+func ClearAllExtensions(pb Message) {
|
|
|
|
+ if epb, doki := pb.(extensionsBytes); doki {
|
|
ext := epb.GetExtensions()
|
|
ext := epb.GetExtensions()
|
|
- et := reflect.TypeOf(extension.ExtensionType)
|
|
|
|
- props := extensionProperties(extension)
|
|
|
|
- p := NewBuffer(nil)
|
|
|
|
- x := reflect.New(et)
|
|
|
|
- x.Elem().Set(reflect.ValueOf(value))
|
|
|
|
- if err := props.enc(p, props, toStructPointer(x)); err != nil {
|
|
|
|
- return err
|
|
|
|
- }
|
|
|
|
- *ext = append(*ext, p.buf...)
|
|
|
|
|
|
+ *ext = []byte{}
|
|
|
|
+ return
|
|
|
|
+ }
|
|
|
|
+ epb, ok := extendable(pb)
|
|
|
|
+ if !ok {
|
|
|
|
+ return
|
|
|
|
+ }
|
|
|
|
+ m := epb.extensionsWrite()
|
|
|
|
+ for k := range m {
|
|
|
|
+ delete(m, k)
|
|
}
|
|
}
|
|
- return nil
|
|
|
|
}
|
|
}
|
|
|
|
|
|
// A global registry of extensions.
|
|
// A global registry of extensions.
|