| // 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/internal/pragma" |
| "google.golang.org/protobuf/reflect/protoreflect" |
| ) |
| |
| // MergeOptions configures the merger. |
| // |
| // Example usage: |
| // MergeOptions{Shallow: true}.Merge(dst, src) |
| type MergeOptions struct { |
| pragma.NoUnkeyedLiterals |
| |
| // Shallow configures Merge to shallow copy messages, lists, and maps |
| // instead of allocating new ones in the destination if it does not already |
| // have one populated. Scalar bytes are copied by reference. |
| // If true, Merge must be given messages of the same concrete type. |
| // |
| // If false, Merge is guaranteed to produce deep copies of all mutable |
| // objects from the source into the destination. Since scalar bytes are |
| // mutable they are deep copied as a result. |
| // |
| // Invariant: |
| // var dst1, dst2 Message = ... |
| // Equal(dst1, dst2) // assume equal initially |
| // MergeOptions{Shallow: true}.Merge(dst1, src) |
| // MergeOptions{Shallow: false}.Merge(dst2, src) |
| // Equal(dst1, dst2) // equal regardless of whether Shallow is specified |
| Shallow bool |
| } |
| |
| // Clone returns a deep copy of m. |
| // See MergeOptions.Clone for details. |
| func Clone(m Message) Message { |
| return MergeOptions{}.Clone(m) |
| } |
| |
| // Merge merges src into dst, which must be messages with the same descriptor. |
| // See MergeOptions.Merge for details. |
| func Merge(dst, src Message) { |
| MergeOptions{}.Merge(dst, src) |
| } |
| |
| // Clone returns a copy of m. |
| // If Shallow is specified it makes a new message and shallow copies m into it. |
| // If the top-level message is invalid, it returns an invalid message as well. |
| func (o MergeOptions) 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. |
| return o.cloneMessage(m.ProtoReflect()).Interface() |
| } |
| |
| func (o MergeOptions) cloneMessage(src protoreflect.Message) (dst protoreflect.Message) { |
| if !src.IsValid() { |
| return src.Type().Zero() |
| } |
| dst = src.New() |
| o.mergeMessage(dst, src) |
| return dst |
| } |
| |
| // 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 (o MergeOptions) Merge(dst, src Message) { |
| dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect() |
| if o.Shallow { |
| if dstMsg.Type() != srcMsg.Type() { |
| panic("type mismatch") |
| } |
| } else { |
| if dstMsg.Descriptor() != srcMsg.Descriptor() { |
| panic("descriptor mismatch") |
| } |
| } |
| o.mergeMessage(dstMsg, srcMsg) |
| } |
| |
| func (o MergeOptions) mergeMessage(dst, src protoreflect.Message) { |
| src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { |
| switch { |
| case fd.IsList(): |
| if o.Shallow && !dst.Has(fd) { |
| dst.Set(fd, v) |
| } else { |
| o.mergeList(dst.Mutable(fd).List(), v.List(), fd) |
| } |
| case fd.IsMap(): |
| if o.Shallow && !dst.Has(fd) { |
| dst.Set(fd, v) |
| } else { |
| o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue()) |
| } |
| case fd.Message() != nil: |
| if o.Shallow && !dst.Has(fd) { |
| dst.Set(fd, v) |
| } else { |
| 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 { |
| if o.Shallow && dst.GetUnknown() == nil { |
| dst.SetUnknown(src.GetUnknown()) |
| } else { |
| 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: |
| if o.Shallow { |
| dst.Append(v) |
| } else { |
| 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: |
| if o.Shallow { |
| dst.Set(k, v) |
| } else { |
| 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 { |
| if o.Shallow { |
| return v |
| } |
| return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...)) |
| } |