go-bot

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
//   - Lists are equal if they are the same length and
37
//     each corresponding element is equal.
38
//
39
//   - Maps 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