Create an actual interface rather than interface{}

Problem with interface{} is that we need all the objects to be in their
"unstructured" form, and this won't work for built-in types that will
still have to be converted to that form. We can further improve the
allocations by removing the need for interface{}, and built a real
interface instead that can be implemented for built-in types.

Author: Antoine Pelisse

fieldpath/element.go

@@ -127,7 +127,7 @@ func KeyByFields(nameValues ...interface{}) *value.FieldList {
 	}
 	out := value.FieldList{}
 	for i := 0; i < len(nameValues)-1; i += 2 {
-		out = append(out, value.Field{Name: nameValues[i].(string), Value: nameValues[i+1]})
+		out = append(out, value.Field{Name: nameValues[i].(string), Value: value.ValueInterface{Value: nameValues[i+1]}})
 	}
 	out.Sort()
 	return &out

fieldpath/element_test.go

@@ -62,9 +62,12 @@ func TestPathElementSet(t *testing.T) {
 	})
 }
 
-func strptr(s string) *string           { return &s }
-func intptr(i int) *int                 { return &i }
-func valptr(i value.Value) *value.Value { return &i }
+func strptr(s string) *string { return &s }
+func intptr(i int) *int       { return &i }
+func valptr(i interface{}) *value.Value {
+	v := value.Value(value.ValueInterface{Value: i})
+	return &v
+}
 
 func TestPathElementLess(t *testing.T) {
 	table := []struct {

fieldpath/fromvalue.go

@@ -43,30 +43,30 @@ type objectWalker struct {
 
 func (w *objectWalker) walk() {
 	switch {
-	case value.IsFloat(w.value):
-	case value.IsInt(w.value):
-	case value.IsString(w.value):
-	case value.IsBool(w.value):
+	case w.value.IsFloat():
+	case w.value.IsInt():
+	case w.value.IsString():
+	case w.value.IsBool():
 		// All leaf fields handled the same way (after the switch
 		// statement).
 
 	// Descend
-	case value.IsList(w.value):
+	case w.value.IsList():
 		// If the list were atomic, we'd break here, but we don't have
 		// a schema, so we can't tell.
 
-		for i, child := range value.ValueList(w.value) {
+		for i := 0; i < w.value.List().Length(); i++ {
 			w2 := *w
-			w2.path = append(w.path, GuessBestListPathElement(i, child))
-			w2.value = child
+			w2.path = append(w.path, GuessBestListPathElement(i, w.value.List().At(i)))
+			w2.value = w.value.List().At(i)
 			w2.walk()
 		}
 		return
-	case value.IsMap(w.value):
+	case w.value.IsMap():
 		// If the map/struct were atomic, we'd break here, but we don't
 		// have a schema, so we can't tell.
 
-		value.ValueMap(w.value).Iterate(func(k string, val value.Value) bool {
+		w.value.Map().Iterate(func(k string, val value.Value) bool {
 			w2 := *w
 			w2.path = append(w.path, PathElement{FieldName: &k})
 			w2.value = val
@@ -96,7 +96,7 @@ var AssociativeListCandidateFieldNames = []string{
 // whether item has any of the fields listed in
 // AssociativeListCandidateFieldNames which have scalar values.
 func GuessBestListPathElement(index int, item value.Value) PathElement {
-	if !value.IsMap(item) {
+	if !item.IsMap() {
 		// Non map items could be parts of sets or regular "atomic"
 		// lists. We won't try to guess whether something should be a
 		// set or not.
@@ -105,12 +105,12 @@ func GuessBestListPathElement(index int, item value.Value) PathElement {
 
 	var keys value.FieldList
 	for _, name := range AssociativeListCandidateFieldNames {
-		f, ok := value.ValueMap(item).Get(name)
+		f, ok := item.Map().Get(name)
 		if !ok {
 			continue
 		}
 		// only accept primitive/scalar types as keys.
-		if f == nil || value.IsMap(f) || value.IsList(f) {
+		if f.IsNull() || f.IsMap() || f.IsList() {
 			continue
 		}
 		keys = append(keys, value.Field{Name: name, Value: f})

fieldpath/fromvalue_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"gopkg.in/yaml.v2"
+	"sigs.k8s.io/structured-merge-diff/value"
 )
 
 func TestFromValue(t *testing.T) {
@@ -70,7 +71,7 @@ func TestFromValue(t *testing.T) {
 			if err != nil {
 				t.Fatalf("couldn't parse: %v", err)
 			}
-			got := SetFromValue(v)
+			got := SetFromValue(value.ValueInterface{Value: v})
 			if !got.Equals(tt.set) {
 				t.Errorf("wanted\n%s\nbut got\n%s\n", tt.set, got)
 			}

fieldpath/path_test.go

@@ -23,7 +23,8 @@ import (
 )
 
 var (
-	_V = func(v value.Value) *value.Value {
+	_V = func(i interface{}) *value.Value {
+		v := value.Value(value.ValueInterface{Value: i})
 		return &v
 	}
 )

fieldpath/pathelementmap_test.go

@@ -29,22 +29,22 @@ func TestPathElementValueMap(t *testing.T) {
 		t.Fatal("Unexpected path-element found in empty map")
 	}
 
-	m.Insert(PathElement{FieldName: strptr("carrot")}, "knife")
-	m.Insert(PathElement{FieldName: strptr("chive")}, 2)
+	m.Insert(PathElement{FieldName: strptr("carrot")}, value.ValueInterface{Value: "knife"})
+	m.Insert(PathElement{FieldName: strptr("chive")}, value.ValueInterface{Value: 2})
 
 	if _, ok := m.Get(PathElement{FieldName: strptr("onion")}); ok {
 		t.Fatal("Unexpected path-element in map")
 	}
 
 	if val, ok := m.Get(PathElement{FieldName: strptr("carrot")}); !ok {
 		t.Fatal("Missing path-element in map")
-	} else if !value.Equals(val, "knife") {
+	} else if !value.Equals(val, value.ValueInterface{Value: "knife"}) {
 		t.Fatalf("Unexpected value found: %#v", val)
 	}
 
 	if val, ok := m.Get(PathElement{FieldName: strptr("chive")}); !ok {
 		t.Fatal("Missing path-element in map")
-	} else if !value.Equals(val, 2) {
+	} else if !value.Equals(val, value.ValueInterface{Value: 2}) {
 		t.Fatalf("Unexpected value found: %#v", val)
 	}
 }

internal/cli/operation.go

@@ -114,7 +114,7 @@ func (m merge) Execute(w io.Writer) error {
 		return err
 	}
 
-	yaml, err := yaml.Marshal(out.AsValue())
+	yaml, err := yaml.Marshal(out.AsValue().Interface())
 	if err != nil {
 		return err
 	}

merge/conflict_test.go

@@ -29,7 +29,8 @@ var (
 	_NS  = fieldpath.NewSet
 	_P   = fieldpath.MakePathOrDie
 	_KBF = fieldpath.KeyByFields
-	_V   = func(v value.Value) *value.Value {
+	_V   = func(i interface{}) *value.Value {
+		v := value.Value(value.ValueInterface{Value: i})
 		return &v
 	}
 )

merge/multiple_appliers_test.go

@@ -985,7 +985,7 @@ func (r repeatingConverter) Convert(v *typed.TypedValue, version fieldpath.APIVe
 	if err != nil {
 		return nil, missingVersionError
 	}
-	y, err := yaml.Marshal(v.AsValue())
+	y, err := yaml.Marshal(v.AsValue().Interface())
 	if err != nil {
 		return nil, err
 	}

typed/helpers.go

@@ -101,16 +101,16 @@ func resolveSchema(s *schema.Schema, tr schema.TypeRef, v *value.Value, ah atomH
 // and validation will fail at a later stage. (with a more useful error)
 func deduceAtom(atom schema.Atom, val *value.Value) schema.Atom {
 	switch {
-	case val == nil:
-	case value.IsFloat(*val), value.IsInt(*val), value.IsString(*val), value.IsBool(*val):
+	case val == nil, *val == nil:
+	case (*val).IsFloat(), (*val).IsInt(), (*val).IsString(), (*val).IsBool():
 		if atom.Scalar != nil {
 			return schema.Atom{Scalar: atom.Scalar}
 		}
-	case value.IsList(*val):
+	case (*val).IsList():
 		if atom.List != nil {
 			return schema.Atom{List: atom.List}
 		}
-	case value.IsMap(*val):
+	case (*val).IsMap():
 		if atom.Map != nil {
 			return schema.Atom{Map: atom.Map}
 		}
@@ -137,43 +137,45 @@ func handleAtom(a schema.Atom, tr schema.TypeRef, ah atomHandler) ValidationErro
 }
 
 // Returns the list, or an error. Reminder: nil is a valid list and might be returned.
-func listValue(val value.Value) ([]interface{}, error) {
-	if val == nil {
+func listValue(val value.Value) (value.List, error) {
+	if val.IsNull() {
 		// Null is a valid list.
 		return nil, nil
 	}
-	l, ok := val.([]interface{})
-	if !ok {
+	if !val.IsList() {
 		return nil, fmt.Errorf("expected list, got %v", val)
 	}
-	return l, nil
+	return val.List(), nil
 }
 
 // Returns the map, or an error. Reminder: nil is a valid map and might be returned.
 func mapValue(val value.Value) (value.Map, error) {
 	if val == nil {
+		return nil, fmt.Errorf("expected map, got nil")
+	}
+	if val.IsNull() {
 		// Null is a valid map.
 		return nil, nil
 	}
-	if !value.IsMap(val) {
+	if !val.IsMap() {
 		return nil, fmt.Errorf("expected map, got %v", val)
 	}
-	return value.ValueMap(val), nil
+	return val.Map(), nil
 }
 
 func keyedAssociativeListItemToPathElement(list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	pe := fieldpath.PathElement{}
-	if child == nil {
+	if child.IsNull() {
 		// For now, the keys are required which means that null entries
 		// are illegal.
 		return pe, errors.New("associative list with keys may not have a null element")
 	}
-	if !value.IsMap(child) {
+	if !child.IsMap() {
 		return pe, errors.New("associative list with keys may not have non-map elements")
 	}
 	keyMap := value.FieldList{}
 	for _, fieldName := range list.Keys {
-		if val, ok := value.ValueMap(child).Get(fieldName); ok {
+		if val, ok := child.Map().Get(fieldName); ok {
 			keyMap = append(keyMap, value.Field{Name: fieldName, Value: val})
 		} else {
 			return pe, fmt.Errorf("associative list with keys has an element that omits key field %q", fieldName)
@@ -187,15 +189,15 @@ func keyedAssociativeListItemToPathElement(list *schema.List, index int, child v
 func setItemToPathElement(list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	pe := fieldpath.PathElement{}
 	switch {
-	case value.IsMap(child):
+	case child.IsMap():
 		// TODO: atomic maps should be acceptable.
 		return pe, errors.New("associative list without keys has an element that's a map type")
-	case value.IsList(child):
+	case child.IsList():
 		// Should we support a set of lists? For the moment
 		// let's say we don't.
 		// TODO: atomic lists should be acceptable.
 		return pe, errors.New("not supported: associative list with lists as elements")
-	case child == nil:
+	case child.IsNull():
 		return pe, errors.New("associative list without keys has an element that's an explicit null")
 	default:
 		// We are a set type.