Home | History | Annotate | Download | only in proto 
      1 // Go support for Protocol Buffers - Google's data interchange format
      2 //
      3 // Copyright 2011 The Go Authors.  All rights reserved.
      4 // https://github.com/golang/protobuf
      5 //
      6 // Redistribution and use in source and binary forms, with or without
      7 // modification, are permitted provided that the following conditions are
      8 // met:
      9 //
     10 //     * Redistributions of source code must retain the above copyright
     11 // notice, this list of conditions and the following disclaimer.
     12 //     * Redistributions in binary form must reproduce the above
     13 // copyright notice, this list of conditions and the following disclaimer
     14 // in the documentation and/or other materials provided with the
     15 // distribution.
     16 //     * Neither the name of Google Inc. nor the names of its
     17 // contributors may be used to endorse or promote products derived from
     18 // this software without specific prior written permission.
     19 //
     20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31 
     32 // Protocol buffer comparison.
     33 
     34 package proto
     35 
     36 import (
     37 	"bytes"
     38 	"log"
     39 	"reflect"
     40 	"strings"
     41 )
     42 
     43 /*
     44 Equal returns true iff protocol buffers a and b are equal.
     45 The arguments must both be pointers to protocol buffer structs.
     46 
     47 Equality is defined in this way:
     48   - Two messages are equal iff they are the same type,
     49     corresponding fields are equal, unknown field sets
     50     are equal, and extensions sets are equal.
     51   - Two set scalar fields are equal iff their values are equal.
     52     If the fields are of a floating-point type, remember that
     53     NaN != x for all x, including NaN. If the message is defined
     54     in a proto3 .proto file, fields are not "set"; specifically,
     55     zero length proto3 "bytes" fields are equal (nil == {}).
     56   - Two repeated fields are equal iff their lengths are the same,
     57     and their corresponding elements are equal. Note a "bytes" field,
     58     although represented by []byte, is not a repeated field and the
     59     rule for the scalar fields described above applies.
     60   - Two unset fields are equal.
     61   - Two unknown field sets are equal if their current
     62     encoded state is equal.
     63   - Two extension sets are equal iff they have corresponding
     64     elements that are pairwise equal.
     65   - Two map fields are equal iff their lengths are the same,
     66     and they contain the same set of elements. Zero-length map
     67     fields are equal.
     68   - Every other combination of things are not equal.
     69 
     70 The return value is undefined if a and b are not protocol buffers.
     71 */
     72 func Equal(a, b Message) bool {
     73 	if a == nil || b == nil {
     74 		return a == b
     75 	}
     76 	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
     77 	if v1.Type() != v2.Type() {
     78 		return false
     79 	}
     80 	if v1.Kind() == reflect.Ptr {
     81 		if v1.IsNil() {
     82 			return v2.IsNil()
     83 		}
     84 		if v2.IsNil() {
     85 			return false
     86 		}
     87 		v1, v2 = v1.Elem(), v2.Elem()
     88 	}
     89 	if v1.Kind() != reflect.Struct {
     90 		return false
     91 	}
     92 	return equalStruct(v1, v2)
     93 }
     94 
     95 // v1 and v2 are known to have the same type.
     96 func equalStruct(v1, v2 reflect.Value) bool {
     97 	sprop := GetProperties(v1.Type())
     98 	for i := 0; i < v1.NumField(); i++ {
     99 		f := v1.Type().Field(i)
    100 		if strings.HasPrefix(f.Name, "XXX_") {
    101 			continue
    102 		}
    103 		f1, f2 := v1.Field(i), v2.Field(i)
    104 		if f.Type.Kind() == reflect.Ptr {
    105 			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
    106 				// both unset
    107 				continue
    108 			} else if n1 != n2 {
    109 				// set/unset mismatch
    110 				return false
    111 			}
    112 			b1, ok := f1.Interface().(raw)
    113 			if ok {
    114 				b2 := f2.Interface().(raw)
    115 				// RawMessage
    116 				if !bytes.Equal(b1.Bytes(), b2.Bytes()) {
    117 					return false
    118 				}
    119 				continue
    120 			}
    121 			f1, f2 = f1.Elem(), f2.Elem()
    122 		}
    123 		if !equalAny(f1, f2, sprop.Prop[i]) {
    124 			return false
    125 		}
    126 	}
    127 
    128 	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
    129 		em2 := v2.FieldByName("XXX_InternalExtensions")
    130 		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
    131 			return false
    132 		}
    133 	}
    134 
    135 	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
    136 		em2 := v2.FieldByName("XXX_extensions")
    137 		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
    138 			return false
    139 		}
    140 	}
    141 
    142 	uf := v1.FieldByName("XXX_unrecognized")
    143 	if !uf.IsValid() {
    144 		return true
    145 	}
    146 
    147 	u1 := uf.Bytes()
    148 	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
    149 	if !bytes.Equal(u1, u2) {
    150 		return false
    151 	}
    152 
    153 	return true
    154 }
    155 
    156 // v1 and v2 are known to have the same type.
    157 // prop may be nil.
    158 func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
    159 	if v1.Type() == protoMessageType {
    160 		m1, _ := v1.Interface().(Message)
    161 		m2, _ := v2.Interface().(Message)
    162 		return Equal(m1, m2)
    163 	}
    164 	switch v1.Kind() {
    165 	case reflect.Bool:
    166 		return v1.Bool() == v2.Bool()
    167 	case reflect.Float32, reflect.Float64:
    168 		return v1.Float() == v2.Float()
    169 	case reflect.Int32, reflect.Int64:
    170 		return v1.Int() == v2.Int()
    171 	case reflect.Interface:
    172 		// Probably a oneof field; compare the inner values.
    173 		n1, n2 := v1.IsNil(), v2.IsNil()
    174 		if n1 || n2 {
    175 			return n1 == n2
    176 		}
    177 		e1, e2 := v1.Elem(), v2.Elem()
    178 		if e1.Type() != e2.Type() {
    179 			return false
    180 		}
    181 		return equalAny(e1, e2, nil)
    182 	case reflect.Map:
    183 		if v1.Len() != v2.Len() {
    184 			return false
    185 		}
    186 		for _, key := range v1.MapKeys() {
    187 			val2 := v2.MapIndex(key)
    188 			if !val2.IsValid() {
    189 				// This key was not found in the second map.
    190 				return false
    191 			}
    192 			if !equalAny(v1.MapIndex(key), val2, nil) {
    193 				return false
    194 			}
    195 		}
    196 		return true
    197 	case reflect.Ptr:
    198 		// Maps may have nil values in them, so check for nil.
    199 		if v1.IsNil() && v2.IsNil() {
    200 			return true
    201 		}
    202 		if v1.IsNil() != v2.IsNil() {
    203 			return false
    204 		}
    205 		return equalAny(v1.Elem(), v2.Elem(), prop)
    206 	case reflect.Slice:
    207 		if v1.Type().Elem().Kind() == reflect.Uint8 {
    208 			// short circuit: []byte
    209 
    210 			// Edge case: if this is in a proto3 message, a zero length
    211 			// bytes field is considered the zero value.
    212 			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
    213 				return true
    214 			}
    215 			if v1.IsNil() != v2.IsNil() {
    216 				return false
    217 			}
    218 			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
    219 		}
    220 
    221 		if v1.Len() != v2.Len() {
    222 			return false
    223 		}
    224 		for i := 0; i < v1.Len(); i++ {
    225 			if !equalAny(v1.Index(i), v2.Index(i), prop) {
    226 				return false
    227 			}
    228 		}
    229 		return true
    230 	case reflect.String:
    231 		return v1.Interface().(string) == v2.Interface().(string)
    232 	case reflect.Struct:
    233 		return equalStruct(v1, v2)
    234 	case reflect.Uint32, reflect.Uint64:
    235 		return v1.Uint() == v2.Uint()
    236 	}
    237 
    238 	// unknown type, so not a protocol buffer
    239 	log.Printf("proto: don't know how to compare %v", v1)
    240 	return false
    241 }
    242 
    243 // base is the struct type that the extensions are based on.
    244 // x1 and x2 are InternalExtensions.
    245 func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
    246 	em1, _ := x1.extensionsRead()
    247 	em2, _ := x2.extensionsRead()
    248 	return equalExtMap(base, em1, em2)
    249 }
    250 
    251 func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
    252 	if len(em1) != len(em2) {
    253 		return false
    254 	}
    255 
    256 	for extNum, e1 := range em1 {
    257 		e2, ok := em2[extNum]
    258 		if !ok {
    259 			return false
    260 		}
    261 
    262 		m1, m2 := e1.value, e2.value
    263 
    264 		if m1 != nil && m2 != nil {
    265 			// Both are unencoded.
    266 			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
    267 				return false
    268 			}
    269 			continue
    270 		}
    271 
    272 		// At least one is encoded. To do a semantically correct comparison
    273 		// we need to unmarshal them first.
    274 		var desc *ExtensionDesc
    275 		if m := extensionMaps[base]; m != nil {
    276 			desc = m[extNum]
    277 		}
    278 		if desc == nil {
    279 			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
    280 			continue
    281 		}
    282 		var err error
    283 		if m1 == nil {
    284 			m1, err = decodeExtension(e1.enc, desc)
    285 		}
    286 		if m2 == nil && err == nil {
    287 			m2, err = decodeExtension(e2.enc, desc)
    288 		}
    289 		if err != nil {
    290 			// The encoded form is invalid.
    291 			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
    292 			return false
    293 		}
    294 		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
    295 			return false
    296 		}
    297 	}
    298 
    299 	return true
    300 }
    301