merge.go

Documentation: google.golang.org/protobuf/proto

     1  // Copyright 2019 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package proto
     6  
     7  import (
     8  	"fmt"
     9  
    10  	"google.golang.org/protobuf/reflect/protoreflect"
    11  	"google.golang.org/protobuf/runtime/protoiface"
    12  )
    13  
    14  // Merge merges src into dst, which must be a message with the same descriptor.
    15  //
    16  // Populated scalar fields in src are copied to dst, while populated
    17  // singular messages in src are merged into dst by recursively calling Merge.
    18  // The elements of every list field in src is appended to the corresponded
    19  // list fields in dst. The entries of every map field in src is copied into
    20  // the corresponding map field in dst, possibly replacing existing entries.
    21  // The unknown fields of src are appended to the unknown fields of dst.
    22  //
    23  // It is semantically equivalent to unmarshaling the encoded form of src
    24  // into dst with the [UnmarshalOptions.Merge] option specified.
    25  func Merge(dst, src Message) {
    26  	// TODO: Should nil src be treated as semantically equivalent to a
    27  	// untyped, read-only, empty message? What about a nil dst?
    28  
    29  	dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect()
    30  	if dstMsg.Descriptor() != srcMsg.Descriptor() {
    31  		if got, want := dstMsg.Descriptor().FullName(), srcMsg.Descriptor().FullName(); got != want {
    32  			panic(fmt.Sprintf("descriptor mismatch: %v != %v", got, want))
    33  		}
    34  		panic("descriptor mismatch")
    35  	}
    36  	mergeOptions{}.mergeMessage(dstMsg, srcMsg)
    37  }
    38  
    39  // Clone returns a deep copy of m.
    40  // If the top-level message is invalid, it returns an invalid message as well.
    41  func Clone(m Message) Message {
    42  	// NOTE: Most usages of Clone assume the following properties:
    43  	//	t := reflect.TypeOf(m)
    44  	//	t == reflect.TypeOf(m.ProtoReflect().New().Interface())
    45  	//	t == reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface())
    46  	//
    47  	// Embedding protobuf messages breaks this since the parent type will have
    48  	// a forwarded ProtoReflect method, but the Interface method will return
    49  	// the underlying embedded message type.
    50  	if m == nil {
    51  		return nil
    52  	}
    53  	src := m.ProtoReflect()
    54  	if !src.IsValid() {
    55  		return src.Type().Zero().Interface()
    56  	}
    57  	dst := src.New()
    58  	mergeOptions{}.mergeMessage(dst, src)
    59  	return dst.Interface()
    60  }
    61  
    62  // mergeOptions provides a namespace for merge functions, and can be
    63  // exported in the future if we add user-visible merge options.
    64  type mergeOptions struct{}
    65  
    66  func (o mergeOptions) mergeMessage(dst, src protoreflect.Message) {
    67  	methods := protoMethods(dst)
    68  	if methods != nil && methods.Merge != nil {
    69  		in := protoiface.MergeInput{
    70  			Destination: dst,
    71  			Source:      src,
    72  		}
    73  		out := methods.Merge(in)
    74  		if out.Flags&protoiface.MergeComplete != 0 {
    75  			return
    76  		}
    77  	}
    78  
    79  	if !dst.IsValid() {
    80  		panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
    81  	}
    82  
    83  	src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
    84  		switch {
    85  		case fd.IsList():
    86  			o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
    87  		case fd.IsMap():
    88  			o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
    89  		case fd.Message() != nil:
    90  			o.mergeMessage(dst.Mutable(fd).Message(), v.Message())
    91  		case fd.Kind() == protoreflect.BytesKind:
    92  			dst.Set(fd, o.cloneBytes(v))
    93  		default:
    94  			dst.Set(fd, v)
    95  		}
    96  		return true
    97  	})
    98  
    99  	if len(src.GetUnknown()) > 0 {
   100  		dst.SetUnknown(append(dst.GetUnknown(), src.GetUnknown()...))
   101  	}
   102  }
   103  
   104  func (o mergeOptions) mergeList(dst, src protoreflect.List, fd protoreflect.FieldDescriptor) {
   105  	// Merge semantics appends to the end of the existing list.
   106  	for i, n := 0, src.Len(); i < n; i++ {
   107  		switch v := src.Get(i); {
   108  		case fd.Message() != nil:
   109  			dstv := dst.NewElement()
   110  			o.mergeMessage(dstv.Message(), v.Message())
   111  			dst.Append(dstv)
   112  		case fd.Kind() == protoreflect.BytesKind:
   113  			dst.Append(o.cloneBytes(v))
   114  		default:
   115  			dst.Append(v)
   116  		}
   117  	}
   118  }
   119  
   120  func (o mergeOptions) mergeMap(dst, src protoreflect.Map, fd protoreflect.FieldDescriptor) {
   121  	// Merge semantics replaces, rather than merges into existing entries.
   122  	src.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
   123  		switch {
   124  		case fd.Message() != nil:
   125  			dstv := dst.NewValue()
   126  			o.mergeMessage(dstv.Message(), v.Message())
   127  			dst.Set(k, dstv)
   128  		case fd.Kind() == protoreflect.BytesKind:
   129  			dst.Set(k, o.cloneBytes(v))
   130  		default:
   131  			dst.Set(k, v)
   132  		}
   133  		return true
   134  	})
   135  }
   136  
   137  func (o mergeOptions) cloneBytes(v protoreflect.Value) protoreflect.Value {
   138  	return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...))
   139  }
   140
View as plain text