bump smd

vendor/sigs.k8s.io/structured-merge-diff/value/value.go

@@ -18,6 +18,7 @@ package value
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 )
 
@@ -33,6 +34,85 @@ type Value struct {
 	Null         bool // represents an explicit `"foo" = null`
 }
 
+// Less provides a total ordering for Value (so that they can be sorted, even
+// if they are of different types).
+func (v Value) Less(rhs Value) bool {
+	if v.FloatValue != nil {
+		if rhs.FloatValue == nil {
+			// Extra: compare floats and ints numerically.
+			if rhs.IntValue != nil {
+				return float64(*v.FloatValue) < float64(*rhs.IntValue)
+			}
+			return true
+		}
+		return *v.FloatValue < *rhs.FloatValue
+	} else if rhs.FloatValue != nil {
+		// Extra: compare floats and ints numerically.
+		if v.IntValue != nil {
+			return float64(*v.IntValue) < float64(*rhs.FloatValue)
+		}
+		return false
+	}
+
+	if v.IntValue != nil {
+		if rhs.IntValue == nil {
+			return true
+		}
+		return *v.IntValue < *rhs.IntValue
+	} else if rhs.IntValue != nil {
+		return false
+	}
+
+	if v.StringValue != nil {
+		if rhs.StringValue == nil {
+			return true
+		}
+		return *v.StringValue < *rhs.StringValue
+	} else if rhs.StringValue != nil {
+		return false
+	}
+
+	if v.BooleanValue != nil {
+		if rhs.BooleanValue == nil {
+			return true
+		}
+		if *v.BooleanValue == *rhs.BooleanValue {
+			return false
+		}
+		return *v.BooleanValue == false
+	} else if rhs.BooleanValue != nil {
+		return false
+	}
+
+	if v.ListValue != nil {
+		if rhs.ListValue == nil {
+			return true
+		}
+		return v.ListValue.Less(rhs.ListValue)
+	} else if rhs.ListValue != nil {
+		return false
+	}
+	if v.MapValue != nil {
+		if rhs.MapValue == nil {
+			return true
+		}
+		return v.MapValue.Less(rhs.MapValue)
+	} else if rhs.MapValue != nil {
+		return false
+	}
+	if v.Null {
+		if !rhs.Null {
+			return true
+		}
+		return false
+	} else if rhs.Null {
+		return false
+	}
+
+	// Invalid Value-- nothing is set.
+	return false
+}
+
 type Int int64
 type Float float64
 type String string
@@ -49,6 +129,35 @@ type List struct {
 	Items []Value
 }
 
+// Less compares two lists lexically.
+func (l *List) Less(rhs *List) bool {
+	i := 0
+	for {
+		if i >= len(l.Items) && i >= len(rhs.Items) {
+			// Lists are the same length and all items are equal.
+			return false
+		}
+		if i >= len(l.Items) {
+			// LHS is shorter.
+			return true
+		}
+		if i >= len(rhs.Items) {
+			// RHS is shorter.
+			return false
+		}
+		if l.Items[i].Less(rhs.Items[i]) {
+			// LHS is less; return
+			return true
+		}
+		if rhs.Items[i].Less(l.Items[i]) {
+			// RHS is less; return
+			return false
+		}
+		// The items are equal; continue.
+		i++
+	}
+}
+
 // Map is a map of key-value pairs. It represents both structs and maps. We use
 // a list and a go-language map to preserve order.
 //
@@ -59,6 +168,58 @@ type Map struct {
 	// may be nil; lazily constructed.
 	// TODO: Direct modifications to Items above will cause serious problems.
 	index map[string]*Field
+	// may be empty; lazily constructed.
+	// TODO: Direct modifications to Items above will cause serious problems.
+	order []int
+}
+
+func (m *Map) computeOrder() {
+	if len(m.order) != len(m.Items) {
+		m.order = make([]int, len(m.Items))
+		for i := range m.order {
+			m.order[i] = i
+		}
+		sort.SliceStable(m.order, func(i, j int) bool {
+			return m.Items[m.order[i]].Name < m.Items[m.order[j]].Name
+		})
+	}
+}
+
+// Less compares two maps lexically.
+func (m *Map) Less(rhs *Map) bool {
+	m.computeOrder()
+	rhs.computeOrder()
+
+	i := 0
+	for {
+		if i >= len(m.order) && i >= len(rhs.order) {
+			// Maps are the same length and all items are equal.
+			return false
+		}
+		if i >= len(m.order) {
+			// LHS is shorter.
+			return true
+		}
+		if i >= len(rhs.order) {
+			// RHS is shorter.
+			return false
+		}
+		fa, fb := &m.Items[m.order[i]], &rhs.Items[rhs.order[i]]
+		if fa.Name != fb.Name {
+			// the map having the field name that sorts lexically less is "less"
+			return fa.Name < fb.Name
+		}
+		if fa.Value.Less(fb.Value) {
+			// LHS is less; return
+			return true
+		}
+		if fb.Value.Less(fa.Value) {
+			// RHS is less; return
+			return false
+		}
+		// The items are equal; continue.
+		i++
+	}
 }
 
 // Get returns the (Field, true) or (nil, false) if it is not present
@@ -82,6 +243,7 @@ func (m *Map) Set(key string, value Value) {
 	}
 	m.Items = append(m.Items, Field{Name: key, Value: value})
 	m.index = nil // Since the append might have reallocated
+	m.order = nil
 }
 
 // Delete removes the key from the set.
@@ -94,6 +256,7 @@ func (m *Map) Delete(key string) {
 	}
 	m.Items = items
 	m.index = nil // Since the list has changed
+	m.order = nil
 }
 
 // StringValue returns s as a scalar string Value.