mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-01 11:58:21 +00:00
cf33a9a274
We're still debating what the semantics of shallow merges should be, and what the use case for them (if any) is. There's no need to commit ourselves to this feature at this time; drop it for now. Remove the exported MergeOptions type, since the only option is gone. We can trivially add it back in the future if we need it. Change-Id: I4c8697cae69cc66eed1ea65de84b982f20e1be44 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/219145 Reviewed-by: Joe Tsai <joetsai@google.com>
112 lines
3.6 KiB
Go
112 lines
3.6 KiB
Go
// Copyright 2019 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 proto
|
|
|
|
import (
|
|
"google.golang.org/protobuf/reflect/protoreflect"
|
|
)
|
|
|
|
// Merge merges src into dst, which must be messages with the same descriptor.
|
|
//
|
|
// Populated scalar fields in src are copied to dst, while populated
|
|
// singular messages in src are merged into dst by recursively calling Merge.
|
|
// The elements of every list field in src is appended to the corresponded
|
|
// list fields in dst. The entries of every map field in src is copied into
|
|
// the corresponding map field in dst, possibly replacing existing entries.
|
|
// The unknown fields of src are appended to the unknown fields of dst.
|
|
//
|
|
// It is semantically equivalent to unmarshaling the encoded form of src
|
|
// into dst with the UnmarshalOptions.Merge option specified.
|
|
func Merge(dst, src Message) {
|
|
dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect()
|
|
if dstMsg.Descriptor() != srcMsg.Descriptor() {
|
|
panic("descriptor mismatch")
|
|
}
|
|
mergeOptions{}.mergeMessage(dstMsg, srcMsg)
|
|
}
|
|
|
|
// Clone returns a copy of m.
|
|
// If the top-level message is invalid, it returns an invalid message as well.
|
|
func Clone(m Message) Message {
|
|
// NOTE: Most usages of Clone assume the following properties:
|
|
// t := reflect.TypeOf(m)
|
|
// t == reflect.TypeOf(m.ProtoReflect().New().Interface())
|
|
// t == reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface())
|
|
//
|
|
// Embedding protobuf messages breaks this since the parent type will have
|
|
// a forwarded ProtoReflect method, but the Interface method will return
|
|
// the underlying embedded message type.
|
|
src := m.ProtoReflect()
|
|
if !src.IsValid() {
|
|
return src.Type().Zero().Interface()
|
|
}
|
|
dst := src.New()
|
|
mergeOptions{}.mergeMessage(dst, src)
|
|
return dst.Interface()
|
|
}
|
|
|
|
// mergeOptions provides a namespace for merge functions, and can be
|
|
// exported in the future if we add user-visible merge options.
|
|
type mergeOptions struct{}
|
|
|
|
func (o mergeOptions) mergeMessage(dst, src protoreflect.Message) {
|
|
src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
|
|
switch {
|
|
case fd.IsList():
|
|
o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
|
|
case fd.IsMap():
|
|
o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
|
|
case fd.Message() != nil:
|
|
o.mergeMessage(dst.Mutable(fd).Message(), v.Message())
|
|
case fd.Kind() == protoreflect.BytesKind:
|
|
dst.Set(fd, o.cloneBytes(v))
|
|
default:
|
|
dst.Set(fd, v)
|
|
}
|
|
return true
|
|
})
|
|
|
|
if len(src.GetUnknown()) > 0 {
|
|
dst.SetUnknown(append(dst.GetUnknown(), src.GetUnknown()...))
|
|
}
|
|
}
|
|
|
|
func (o mergeOptions) mergeList(dst, src protoreflect.List, fd protoreflect.FieldDescriptor) {
|
|
// Merge semantics appends to the end of the existing list.
|
|
for i, n := 0, src.Len(); i < n; i++ {
|
|
switch v := src.Get(i); {
|
|
case fd.Message() != nil:
|
|
dstv := dst.NewElement()
|
|
o.mergeMessage(dstv.Message(), v.Message())
|
|
dst.Append(dstv)
|
|
case fd.Kind() == protoreflect.BytesKind:
|
|
dst.Append(o.cloneBytes(v))
|
|
default:
|
|
dst.Append(v)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (o mergeOptions) mergeMap(dst, src protoreflect.Map, fd protoreflect.FieldDescriptor) {
|
|
// Merge semantics replaces, rather than merges into existing entries.
|
|
src.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
|
|
switch {
|
|
case fd.Message() != nil:
|
|
dstv := dst.NewValue()
|
|
o.mergeMessage(dstv.Message(), v.Message())
|
|
dst.Set(k, dstv)
|
|
case fd.Kind() == protoreflect.BytesKind:
|
|
dst.Set(k, o.cloneBytes(v))
|
|
default:
|
|
dst.Set(k, v)
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
|
|
func (o mergeOptions) cloneBytes(v protoreflect.Value) protoreflect.Value {
|
|
return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...))
|
|
}
|