1 // Copyright 2022 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 protoreflect
6 7 import (
8 "bytes"
9 "fmt"
10 "math"
11 "reflect"
12 13 "google.golang.org/protobuf/encoding/protowire"
14 )
15 16 // Equal reports whether v1 and v2 are recursively equal.
17 //
18 // - Values of different types are always unequal.
19 //
20 // - Bytes values are equal if they contain identical bytes.
21 // Empty bytes (regardless of nil-ness) are considered equal.
22 //
23 // - Floating point values are equal if they contain the same value.
24 // Unlike the == operator, a NaN is equal to another NaN.
25 //
26 // - Enums are equal if they contain the same number.
27 // Since [Value] does not contain an enum descriptor,
28 // enum values do not consider the type of the enum.
29 //
30 // - Other scalar values are equal if they contain the same value.
31 //
32 // - [Message] values are equal if they belong to the same message descriptor,
33 // have the same set of populated known and extension field values,
34 // and the same set of unknown fields values.
35 //
36 // - [List] values are equal if they are the same length and
37 // each corresponding element is equal.
38 //
39 // - [Map] values are equal if they have the same set of keys and
40 // the corresponding value for each key is equal.
41 func (v1 Value) Equal(v2 Value) bool {
42 return equalValue(v1, v2)
43 }
44 45 func equalValue(x, y Value) bool {
46 eqType := x.typ == y.typ
47 switch x.typ {
48 case nilType:
49 return eqType
50 case boolType:
51 return eqType && x.Bool() == y.Bool()
52 case int32Type, int64Type:
53 return eqType && x.Int() == y.Int()
54 case uint32Type, uint64Type:
55 return eqType && x.Uint() == y.Uint()
56 case float32Type, float64Type:
57 return eqType && equalFloat(x.Float(), y.Float())
58 case stringType:
59 return eqType && x.String() == y.String()
60 case bytesType:
61 return eqType && bytes.Equal(x.Bytes(), y.Bytes())
62 case enumType:
63 return eqType && x.Enum() == y.Enum()
64 default:
65 switch x := x.Interface().(type) {
66 case Message:
67 y, ok := y.Interface().(Message)
68 return ok && equalMessage(x, y)
69 case List:
70 y, ok := y.Interface().(List)
71 return ok && equalList(x, y)
72 case Map:
73 y, ok := y.Interface().(Map)
74 return ok && equalMap(x, y)
75 default:
76 panic(fmt.Sprintf("unknown type: %T", x))
77 }
78 }
79 }
80 81 // equalFloat compares two floats, where NaNs are treated as equal.
82 func equalFloat(x, y float64) bool {
83 if math.IsNaN(x) || math.IsNaN(y) {
84 return math.IsNaN(x) && math.IsNaN(y)
85 }
86 return x == y
87 }
88 89 // equalMessage compares two messages.
90 func equalMessage(mx, my Message) bool {
91 if mx.Descriptor() != my.Descriptor() {
92 return false
93 }
94 95 nx := 0
96 equal := true
97 mx.Range(func(fd FieldDescriptor, vx Value) bool {
98 nx++
99 vy := my.Get(fd)
100 equal = my.Has(fd) && equalValue(vx, vy)
101 return equal
102 })
103 if !equal {
104 return false
105 }
106 ny := 0
107 my.Range(func(fd FieldDescriptor, vx Value) bool {
108 ny++
109 return true
110 })
111 if nx != ny {
112 return false
113 }
114 115 return equalUnknown(mx.GetUnknown(), my.GetUnknown())
116 }
117 118 // equalList compares two lists.
119 func equalList(x, y List) bool {
120 if x.Len() != y.Len() {
121 return false
122 }
123 for i := x.Len() - 1; i >= 0; i-- {
124 if !equalValue(x.Get(i), y.Get(i)) {
125 return false
126 }
127 }
128 return true
129 }
130 131 // equalMap compares two maps.
132 func equalMap(x, y Map) bool {
133 if x.Len() != y.Len() {
134 return false
135 }
136 equal := true
137 x.Range(func(k MapKey, vx Value) bool {
138 vy := y.Get(k)
139 equal = y.Has(k) && equalValue(vx, vy)
140 return equal
141 })
142 return equal
143 }
144 145 // equalUnknown compares unknown fields by direct comparison on the raw bytes
146 // of each individual field number.
147 func equalUnknown(x, y RawFields) bool {
148 if len(x) != len(y) {
149 return false
150 }
151 if bytes.Equal([]byte(x), []byte(y)) {
152 return true
153 }
154 155 mx := make(map[FieldNumber]RawFields)
156 my := make(map[FieldNumber]RawFields)
157 for len(x) > 0 {
158 fnum, _, n := protowire.ConsumeField(x)
159 mx[fnum] = append(mx[fnum], x[:n]...)
160 x = x[n:]
161 }
162 for len(y) > 0 {
163 fnum, _, n := protowire.ConsumeField(y)
164 my[fnum] = append(my[fnum], y[:n]...)
165 y = y[n:]
166 }
167 return reflect.DeepEqual(mx, my)
168 }
169