Create map of PathElement to Value and use it instead of Strings

Author: Antoine Pelisse

typed/merge.go

@@ -17,11 +17,62 @@ limitations under the License.
 package typed
 
 import (
+	"sort"
+
 	"sigs.k8s.io/structured-merge-diff/fieldpath"
 	"sigs.k8s.io/structured-merge-diff/schema"
 	"sigs.k8s.io/structured-merge-diff/value"
 )
 
+type pathElementValueMap struct {
+	members sortedPathElementValues
+}
+
+type pathElementValue struct {
+	PathElement fieldpath.PathElement
+	Value       value.Value
+}
+
+type sortedPathElementValues []pathElementValue
+
+// Implement the sort interface; this would permit bulk creation, which would
+// be faster than doing it one at a time via Insert.
+func (spev sortedPathElementValues) Len() int { return len(spev) }
+func (spev sortedPathElementValues) Less(i, j int) bool {
+	return spev[i].PathElement.Less(spev[j].PathElement)
+}
+func (spev sortedPathElementValues) Swap(i, j int) { spev[i], spev[j] = spev[j], spev[i] }
+
+// Insert adds pe to the set.
+func (s *pathElementValueMap) Insert(pe fieldpath.PathElement, v value.Value) {
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].PathElement.Less(pe)
+	})
+	if loc == len(s.members) {
+		s.members = append(s.members, pathElementValue{pe, v})
+		return
+	}
+	if s.members[loc].PathElement.Equals(pe) {
+		return
+	}
+	s.members = append(s.members, pathElementValue{})
+	copy(s.members[loc+1:], s.members[loc:])
+	s.members[loc] = pathElementValue{pe, v}
+}
+
+func (s *pathElementValueMap) Get(pe fieldpath.PathElement) *value.Value {
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].PathElement.Less(pe)
+	})
+	if loc == len(s.members) {
+		return nil
+	}
+	if s.members[loc].PathElement.Equals(pe) {
+		return &s.members[loc].Value
+	}
+	return nil
+}
+
 type mergingWalker struct {
 	errorFormatter
 	lhs     *value.Value
@@ -168,7 +219,7 @@ func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (err
 	rhsOrder := []fieldpath.PathElement{}
 
 	// First, collect all RHS children.
-	observedRHS := map[string]value.Value{}
+	observedRHS := pathElementValueMap{}
 	if rhs != nil {
 		for i, child := range rhs.Items {
 			pe, err := listItemToPathElement(t, i, child)
@@ -179,17 +230,16 @@ func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (err
 				// this element.
 				continue
 			}
-			keyStr := pe.String()
-			if _, found := observedRHS[keyStr]; found {
-				errs = append(errs, w.errorf("rhs: duplicate entries for key %v", keyStr)...)
+			if observedRHS.Get(pe) != nil {
+				errs = append(errs, w.errorf("rhs: duplicate entries for key %v", pe.String())...)
 			}
-			observedRHS[keyStr] = child
+			observedRHS.Insert(pe, child)
 			rhsOrder = append(rhsOrder, pe)
 		}
 	}
 
 	// Then merge with LHS children.
-	observedLHS := map[string]struct{}{}
+	observedLHS := fieldpath.PathElementSet{}
 	if lhs != nil {
 		for i, child := range lhs.Items {
 			pe, err := listItemToPathElement(t, i, child)
@@ -200,39 +250,38 @@ func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (err
 				// this element.
 				continue
 			}
-			keyStr := pe.String()
-			if _, found := observedLHS[keyStr]; found {
-				errs = append(errs, w.errorf("lhs: duplicate entries for key %v", keyStr)...)
+			if observedLHS.Has(pe) {
+				errs = append(errs, w.errorf("lhs: duplicate entries for key %v", pe.String())...)
 				continue
 			}
-			observedLHS[keyStr] = struct{}{}
+			observedLHS.Insert(pe)
 			w2 := w.prepareDescent(pe, t.ElementType)
 			w2.lhs = &child
-			if rchild, ok := observedRHS[keyStr]; ok {
-				w2.rhs = &rchild
+			if rchild := observedRHS.Get(pe); rchild != nil {
+				w2.rhs = rchild
 			}
 			if newErrs := w2.merge(); len(newErrs) > 0 {
 				errs = append(errs, newErrs...)
 			} else if w2.out != nil {
 				out.Items = append(out.Items, *w2.out)
 			}
 			w.finishDescent(w2)
-			// Keep track of children that have been handled
-			delete(observedRHS, keyStr)
 		}
 	}
 
-	for _, rhsToCheck := range rhsOrder {
-		if unmergedChild, ok := observedRHS[rhsToCheck.String()]; ok {
-			w2 := w.prepareDescent(rhsToCheck, t.ElementType)
-			w2.rhs = &unmergedChild
-			if newErrs := w2.merge(); len(newErrs) > 0 {
-				errs = append(errs, newErrs...)
-			} else if w2.out != nil {
-				out.Items = append(out.Items, *w2.out)
-			}
-			w.finishDescent(w2)
+	for _, pe := range rhsOrder {
+		if observedLHS.Has(pe) {
+			continue
+		}
+		value := observedRHS.Get(pe)
+		w2 := w.prepareDescent(pe, t.ElementType)
+		w2.rhs = value
+		if newErrs := w2.merge(); len(newErrs) > 0 {
+			errs = append(errs, newErrs...)
+		} else if w2.out != nil {
+			out.Items = append(out.Items, *w2.out)
 		}
+		w.finishDescent(w2)
 	}
 
 	if len(out.Items) > 0 {