Change equal for path element

Author: Antoine Pelisse

fieldpath/element.go

@@ -49,50 +49,90 @@ type PathElement struct {
 
 // Less provides an order for path elements.
 func (e PathElement) Less(rhs PathElement) bool {
+	return e.Compare(rhs) < 0
+}
+
+// Compare provides an order for path elements.
+func (e PathElement) Compare(rhs PathElement) int {
 	if e.FieldName != nil {
 		if rhs.FieldName == nil {
-			return true
+			return -1
 		}
-		return *e.FieldName < *rhs.FieldName
+		return strings.Compare(*e.FieldName, *rhs.FieldName)
 	} else if rhs.FieldName != nil {
-		return false
+		return 1
 	}
 
 	if e.Key != nil {
 		if rhs.Key == nil {
-			return true
+			return -1
 		}
-		return e.Key.Less(*rhs.Key)
+		return e.Key.Compare(*rhs.Key)
 	} else if rhs.Key != nil {
-		return false
+		return 1
 	}
 
 	if e.Value != nil {
 		if rhs.Value == nil {
-			return true
+			return -1
 		}
-		return value.Less(*e.Value, *rhs.Value)
+		return value.Compare(*e.Value, *rhs.Value)
 	} else if rhs.Value != nil {
-		return false
+		return 1
 	}
 
 	if e.Index != nil {
 		if rhs.Index == nil {
-			return true
+			return -1
 		}
-		return *e.Index < *rhs.Index
+		if *e.Index < *rhs.Index {
+			return -1
+		} else if *e.Index == *rhs.Index {
+			return 0
+		}
+		return 1
 	} else if rhs.Index != nil {
-		// Yes, I know the next statement is the same.  But this way
-		// the obvious way of extending the function wil be bug-free.
-		return false
+		return 1
 	}
 
-	return false
+	return 0
 }
 
 // Equals returns true if both path elements are equal.
 func (e PathElement) Equals(rhs PathElement) bool {
-	return !e.Less(rhs) && !rhs.Less(e)
+	if e.FieldName != nil {
+		if rhs.FieldName == nil {
+			return false
+		}
+		return *e.FieldName == *rhs.FieldName
+	} else if rhs.FieldName != nil {
+		return false
+	}
+	if e.Key != nil {
+		if rhs.Key == nil {
+			return false
+		}
+		return e.Key.Equals(*rhs.Key)
+	} else if rhs.Key != nil {
+		return false
+	}
+	if e.Value != nil {
+		if rhs.Value == nil {
+			return false
+		}
+		return value.Equals(*e.Value, *rhs.Value)
+	} else if rhs.Value != nil {
+		return false
+	}
+	if e.Index != nil {
+		if rhs.Index == nil {
+			return false
+		}
+		return *e.Index == *rhs.Index
+	} else if rhs.Index != nil {
+		return false
+	}
+	return true
 }
 
 // String presents the path element as a human-readable string.

fieldpath/path.go

@@ -37,32 +37,35 @@ func (fp Path) String() string {
 
 // Equals returns true if the two paths are equivalent.
 func (fp Path) Equals(fp2 Path) bool {
-	return !fp.Less(fp2) && !fp2.Less(fp)
+	if len(fp) != len(fp2) {
+		return false
+	}
+	for i := range fp {
+		if !fp[i].Equals(fp2[i]) {
+			return false
+		}
+	}
+	return true
 }
 
 // Less provides a lexical order for Paths.
-func (fp Path) Less(rhs Path) bool {
+func (fp Path) Compare(rhs Path) int {
 	i := 0
 	for {
 		if i >= len(fp) && i >= len(rhs) {
 			// Paths are the same length and all items are equal.
-			return false
+			return 0
 		}
 		if i >= len(fp) {
 			// LHS is shorter.
-			return true
+			return -1
 		}
 		if i >= len(rhs) {
 			// RHS is shorter.
-			return false
+			return 1
 		}
-		if fp[i].Less(rhs[i]) {
-			// LHS is less; return
-			return true
-		}
-		if rhs[i].Less(fp[i]) {
-			// RHS is less; return
-			return false
+		if c := fp[i].Compare(rhs[i]); c != 0 {
+			return c
 		}
 		// The items are equal; continue.
 		i++

value/fields.go

@@ -79,3 +79,19 @@ func (f FieldList) Compare(rhs FieldList) int {
 		i++
 	}
 }
+
+// Equals returns true if the two fieldslist are equals, false otherwise.
+func (f FieldList) Equals(rhs FieldList) bool {
+	if len(f) != len(rhs) {
+		return false
+	}
+	for i := range f {
+		if f[i].Name != rhs[i].Name {
+			return false
+		}
+		if !Equals(f[i].Value, rhs[i].Value) {
+			return false
+		}
+	}
+	return true
+}