rename value conversion methods

Renames all conversion methods for value.Value
e.g. `Map()` -> `AsMap()`

This removes the implementation of `String() string`.
Without this change, calling String() on a value would have behaved differently than usually expected in go.

Author: Kevin Wiesmüller

fieldpath/fromvalue.go

@@ -55,7 +55,7 @@ func (w *objectWalker) walk() {
 	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.
-		list := w.value.List()
+		list := w.value.AsList()
 		for i := 0; i < list.Length(); i++ {
 			w2 := *w
 			w2.path = append(w.path, GuessBestListPathElement(i, list.At(i)))
@@ -67,7 +67,7 @@ func (w *objectWalker) walk() {
 		// If the map/struct were atomic, we'd break here, but we don't
 		// have a schema, so we can't tell.
 
-		w.value.Map().Iterate(func(k string, val value.Value) bool {
+		w.value.AsMap().Iterate(func(k string, val value.Value) bool {
 			w2 := *w
 			w2.path = append(w.path, PathElement{FieldName: &k})
 			w2.value = val
@@ -106,7 +106,7 @@ func GuessBestListPathElement(index int, item value.Value) PathElement {
 
 	var keys value.FieldList
 	for _, name := range AssociativeListCandidateFieldNames {
-		f, ok := item.Map().Get(name)
+		f, ok := item.AsMap().Get(name)
 		if !ok {
 			continue
 		}

typed/helpers.go

@@ -162,7 +162,7 @@ func listValue(val value.Value) (value.List, error) {
 	if !val.IsList() {
 		return nil, fmt.Errorf("expected list, got %v", val)
 	}
-	return val.List(), nil
+	return val.AsList(), nil
 }
 
 // Returns the map, or an error. Reminder: nil is a valid map and might be returned.
@@ -177,7 +177,7 @@ func mapValue(val value.Value) (value.Map, error) {
 	if !val.IsMap() {
 		return nil, fmt.Errorf("expected map, got %v", val)
 	}
-	return val.Map(), nil
+	return val.AsMap(), nil
 }
 
 func keyedAssociativeListItemToPathElement(list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
@@ -192,7 +192,7 @@ func keyedAssociativeListItemToPathElement(list *schema.List, index int, child v
 	}
 	keyMap := value.FieldList{}
 	for _, fieldName := range list.Keys {
-		if val, ok := child.Map().Get(fieldName); ok {
+		if val, ok := child.AsMap().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)

typed/remove.go

@@ -42,7 +42,7 @@ func (w *removingWalker) doScalar(t *schema.Scalar) ValidationErrors {
 }
 
 func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
-	l := w.value.List()
+	l := w.value.AsList()
 
 	// If list is null, empty, or atomic just return
 	if l == nil || l.Length() == 0 || t.ElementRelationship == schema.Atomic {
@@ -70,7 +70,7 @@ func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
 }
 
 func (w *removingWalker) doMap(t *schema.Map) ValidationErrors {
-	m := w.value.Map()
+	m := w.value.AsMap()
 
 	// If map is null, empty, or atomic just return
 	if m == nil || m.Length() == 0 || t.ElementRelationship == schema.Atomic {

typed/union.go

@@ -36,10 +36,10 @@ func normalizeUnions(w *mergingWalker) error {
 
 	var old value.Map
 	if w.lhs != nil && !w.lhs.IsNull() {
-		old = w.lhs.Map()
+		old = w.lhs.AsMap()
 	}
 	for _, union := range atom.Map.Unions {
-		if err := newUnion(&union).Normalize(old, w.rhs.Map(), value.NewValueInterface(*w.out).Map()); err != nil {
+		if err := newUnion(&union).Normalize(old, w.rhs.AsMap(), value.NewValueInterface(*w.out).AsMap()); err != nil {
 			return err
 		}
 	}
@@ -58,12 +58,12 @@ func normalizeUnionsApply(w *mergingWalker) error {
 
 	var old value.Map
 	if w.lhs != nil && !w.lhs.IsNull() {
-		old = w.lhs.Map()
+		old = w.lhs.AsMap()
 	}
 
 	for _, union := range atom.Map.Unions {
 		out := value.NewValueInterface(*w.out)
-		if err := newUnion(&union).NormalizeApply(old, w.rhs.Map(), out.Map()); err != nil {
+		if err := newUnion(&union).NormalizeApply(old, w.rhs.AsMap(), out.AsMap()); err != nil {
 			return err
 		}
 		*w.out = out.Unstructured()
@@ -126,7 +126,7 @@ func (d *discriminator) Get(m value.Map) discriminated {
 	if !val.IsString() {
 		return ""
 	}
-	return discriminated(val.String())
+	return discriminated(val.AsString())
 }
 
 type fieldsSet map[field]struct{}

value/value.go

@@ -52,30 +52,30 @@ type Value interface {
 	// IsMap returns true if the Value is null, false otherwise.
 	IsNull() bool
 
-	// Map converts the Value into a Map (or panic if the type
+	// AsMap converts the Value into a Map (or panic if the type
 	// doesn't allow it).
-	Map() Map
-	// List converts the Value into a List (or panic if the type
+	AsMap() Map
+	// AsList converts the Value into a List (or panic if the type
 	// doesn't allow it).
-	List() List
-	// Bool converts the Value into a bool (or panic if the type
+	AsList() List
+	// AsBool converts the Value into a bool (or panic if the type
 	// doesn't allow it).
-	Bool() bool
-	// Int converts the Value into an int64 (or panic if the type
+	AsBool() bool
+	// AsInt converts the Value into an int64 (or panic if the type
 	// doesn't allow it).
-	Int() int64
-	// Float converts the Value into a float64 (or panic if the type
+	AsInt() int64
+	// AsFloat converts the Value into a float64 (or panic if the type
 	// doesn't allow it).
-	Float() float64
-	// String converts the Value into a string (or panic if the type
+	AsFloat() float64
+	// AsString converts the Value into a string (or panic if the type
 	// doesn't allow it).
-	String() string
+	AsString() string
 
-	// Returns a value of this type that is no longer needed. The
+	// Recycle returns a value of this type that is no longer needed. The
 	// value shouldn't be used after this call.
 	Recycle()
 
-	// Converts the Value into an Unstructured interface{}.
+	// Unstructured converts the Value into an Unstructured interface{}.
 	Unstructured() interface{}
 }
 
@@ -131,49 +131,49 @@ func Equals(lhs, rhs Value) bool {
 	if lhs.IsFloat() || rhs.IsFloat() {
 		var lf float64
 		if lhs.IsFloat() {
-			lf = lhs.Float()
+			lf = lhs.AsFloat()
 		} else if lhs.IsInt() {
-			lf = float64(lhs.Int())
+			lf = float64(lhs.AsInt())
 		} else {
 			return false
 		}
 		var rf float64
 		if rhs.IsFloat() {
-			rf = rhs.Float()
+			rf = rhs.AsFloat()
 		} else if rhs.IsInt() {
-			rf = float64(rhs.Int())
+			rf = float64(rhs.AsInt())
 		} else {
 			return false
 		}
 		return lf == rf
 	}
 	if lhs.IsInt() {
 		if rhs.IsInt() {
-			return lhs.Int() == rhs.Int()
+			return lhs.AsInt() == rhs.AsInt()
 		}
 		return false
 	}
 	if lhs.IsString() {
 		if rhs.IsString() {
-			return lhs.String() == rhs.String()
+			return lhs.AsString() == rhs.AsString()
 		}
 		return false
 	}
 	if lhs.IsBool() {
 		if rhs.IsBool() {
-			return lhs.Bool() == rhs.Bool()
+			return lhs.AsBool() == rhs.AsBool()
 		}
 		return false
 	}
 	if lhs.IsList() {
 		if rhs.IsList() {
-			return ListEquals(lhs.List(), rhs.List())
+			return ListEquals(lhs.AsList(), rhs.AsList())
 		}
 		return false
 	}
 	if lhs.IsMap() {
 		if rhs.IsMap() {
-			return lhs.Map().Equals(rhs.Map())
+			return lhs.AsMap().Equals(rhs.AsMap())
 		}
 		return false
 	}
@@ -187,29 +187,29 @@ func Equals(lhs, rhs Value) bool {
 	return true
 }
 
-// String returns a human-readable representation of the value.
+// ToString returns a human-readable representation of the value.
 func ToString(v Value) string {
 	if v.IsNull() {
 		return "null"
 	}
 	switch {
 	case v.IsFloat():
-		return fmt.Sprintf("%v", v.Float())
+		return fmt.Sprintf("%v", v.AsFloat())
 	case v.IsInt():
-		return fmt.Sprintf("%v", v.Int())
+		return fmt.Sprintf("%v", v.AsInt())
 	case v.IsString():
-		return fmt.Sprintf("%q", v.String())
+		return fmt.Sprintf("%q", v.AsString())
 	case v.IsBool():
-		return fmt.Sprintf("%v", v.Bool())
+		return fmt.Sprintf("%v", v.AsBool())
 	case v.IsList():
 		strs := []string{}
-		for i := 0; i < v.List().Length(); i++ {
-			strs = append(strs, ToString(v.List().At(i)))
+		for i := 0; i < v.AsList().Length(); i++ {
+			strs = append(strs, ToString(v.AsList().At(i)))
 		}
 		return "[" + strings.Join(strs, ",") + "]"
 	case v.IsMap():
 		strs := []string{}
-		v.Map().Iterate(func(k string, v Value) bool {
+		v.AsMap().Iterate(func(k string, v Value) bool {
 			strs = append(strs, fmt.Sprintf("%v=%v", k, ToString(v)))
 			return true
 		})
@@ -233,15 +233,15 @@ func Compare(lhs, rhs Value) int {
 		if !rhs.IsFloat() {
 			// Extra: compare floats and ints numerically.
 			if rhs.IsInt() {
-				return FloatCompare(lhs.Float(), float64(rhs.Int()))
+				return FloatCompare(lhs.AsFloat(), float64(rhs.AsInt()))
 			}
 			return -1
 		}
-		return FloatCompare(lhs.Float(), rhs.Float())
+		return FloatCompare(lhs.AsFloat(), rhs.AsFloat())
 	} else if rhs.IsFloat() {
 		// Extra: compare floats and ints numerically.
 		if lhs.IsInt() {
-			return FloatCompare(float64(lhs.Int()), rhs.Float())
+			return FloatCompare(float64(lhs.AsInt()), rhs.AsFloat())
 		}
 		return 1
 	}
@@ -250,7 +250,7 @@ func Compare(lhs, rhs Value) int {
 		if !rhs.IsInt() {
 			return -1
 		}
-		return IntCompare(lhs.Int(), rhs.Int())
+		return IntCompare(lhs.AsInt(), rhs.AsInt())
 	} else if rhs.IsInt() {
 		return 1
 	}
@@ -259,7 +259,7 @@ func Compare(lhs, rhs Value) int {
 		if !rhs.IsString() {
 			return -1
 		}
-		return strings.Compare(lhs.String(), rhs.String())
+		return strings.Compare(lhs.AsString(), rhs.AsString())
 	} else if rhs.IsString() {
 		return 1
 	}
@@ -268,7 +268,7 @@ func Compare(lhs, rhs Value) int {
 		if !rhs.IsBool() {
 			return -1
 		}
-		return BoolCompare(lhs.Bool(), rhs.Bool())
+		return BoolCompare(lhs.AsBool(), rhs.AsBool())
 	} else if rhs.IsBool() {
 		return 1
 	}
@@ -277,15 +277,15 @@ func Compare(lhs, rhs Value) int {
 		if !rhs.IsList() {
 			return -1
 		}
-		return ListCompare(lhs.List(), rhs.List())
+		return ListCompare(lhs.AsList(), rhs.AsList())
 	} else if rhs.IsList() {
 		return 1
 	}
 	if lhs.IsMap() {
 		if !rhs.IsMap() {
 			return -1
 		}
-		return MapCompare(lhs.Map(), rhs.Map())
+		return MapCompare(lhs.AsMap(), rhs.AsMap())
 	} else if rhs.IsMap() {
 		return 1
 	}

value/valueunstructured.go

@@ -49,7 +49,7 @@ func (v valueUnstructured) IsMap() bool {
 	return false
 }
 
-func (v valueUnstructured) Map() Map {
+func (v valueUnstructured) AsMap() Map {
 	if v.Value == nil {
 		panic("invalid nil")
 	}
@@ -70,7 +70,7 @@ func (v valueUnstructured) IsList() bool {
 	return ok
 }
 
-func (v valueUnstructured) List() List {
+func (v valueUnstructured) AsList() List {
 	return listUnstructured(v.Value.([]interface{}))
 }
 
@@ -85,7 +85,7 @@ func (v valueUnstructured) IsFloat() bool {
 	return false
 }
 
-func (v valueUnstructured) Float() float64 {
+func (v valueUnstructured) AsFloat() float64 {
 	if f, ok := v.Value.(float32); ok {
 		return float64(f)
 	}
@@ -117,7 +117,7 @@ func (v valueUnstructured) IsInt() bool {
 	return false
 }
 
-func (v valueUnstructured) Int() int64 {
+func (v valueUnstructured) AsInt() int64 {
 	if i, ok := v.Value.(int); ok {
 		return int64(i)
 	} else if i, ok := v.Value.(int8); ok {
@@ -146,7 +146,7 @@ func (v valueUnstructured) IsString() bool {
 	return ok
 }
 
-func (v valueUnstructured) String() string {
+func (v valueUnstructured) AsString() string {
 	return v.Value.(string)
 }
 
@@ -158,7 +158,7 @@ func (v valueUnstructured) IsBool() bool {
 	return ok
 }
 
-func (v valueUnstructured) Bool() bool {
+func (v valueUnstructured) AsBool() bool {
 	return v.Value.(bool)
 }