expose *Into() functions directly

Author: jpbetz

fieldpath/fromvalue.go

@@ -25,20 +25,20 @@ func SetFromValue(v value.Value) *Set {
 	s := NewSet()
 
 	w := objectWalker{
-		path:  Path{},
-		value: v,
-		valueAlloc: value.NewValueFreelist(),
-		do:    func(p Path) { s.Insert(p) },
+		path:      Path{},
+		value:     v,
+		allocator: value.NewValueFreelist(),
+		do:        func(p Path) { s.Insert(p) },
 	}
 
 	w.walk()
 	return s
 }
 
 type objectWalker struct {
-	path  Path
-	value value.Value
-	valueAlloc *value.ValueFreelist
+	path      Path
+	value     value.Value
+	allocator *value.ValueFreelist
 
 	do func(Path)
 }
@@ -57,10 +57,10 @@ 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.
-		l := w.valueAlloc.AsList(w.value)
-		defer w.valueAlloc.Free(l)
-		iter := l.Range()
-		defer iter.Recycle()
+		l := w.value.AsListInto(w.allocator)
+		defer w.allocator.Free(l)
+		iter := l.RangeInto(w.allocator)
+		defer w.allocator.Free(iter)
 		for iter.Next() {
 			i, value := iter.Item()
 			w2 := *w
@@ -73,9 +73,9 @@ 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.
 
-		m := w.valueAlloc.AsMap(w.value)
-		defer w.valueAlloc.Free(m)
-		m.Iterate(func(k string, val value.Value) bool {
+		m := w.value.AsMapInto(w.allocator)
+		defer w.allocator.Free(m)
+		m.IterateInto(w.allocator, func(k string, val value.Value) bool {
 			w2 := *w
 			w2.path = append(w.path, PathElement{FieldName: &k})
 			w2.value = val
@@ -112,8 +112,8 @@ func (w *objectWalker) GuessBestListPathElement(index int, item value.Value) Pat
 		return PathElement{Index: &index}
 	}
 
-	m := w.valueAlloc.AsMap(item)
-	defer w.valueAlloc.Free(m)
+	m := item.AsMapInto(w.allocator)
+	defer w.allocator.Free(m)
 	var keys value.FieldList
 	for _, name := range AssociativeListCandidateFieldNames {
 		f, ok := m.Get(name)

typed/helpers.go

@@ -154,19 +154,19 @@ 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(a *value.ValueFreelist, val value.Value) (value.List, error) {
+func listValue(a value.Allocator, val value.Value) (value.List, error) {
 	if val.IsNull() {
 		// Null is a valid list.
 		return nil, nil
 	}
 	if !val.IsList() {
 		return nil, fmt.Errorf("expected list, got %v", val)
 	}
-	return a.AsList(val), nil
+	return val.AsListInto(a), nil
 }
 
 // Returns the map, or an error. Reminder: nil is a valid map and might be returned.
-func mapValue(a *value.ValueFreelist, val value.Value) (value.Map, error) {
+func mapValue(a value.Allocator, val value.Value) (value.Map, error) {
 	if val == nil {
 		return nil, fmt.Errorf("expected map, got nil")
 	}
@@ -177,10 +177,10 @@ func mapValue(a *value.ValueFreelist, val value.Value) (value.Map, error) {
 	if !val.IsMap() {
 		return nil, fmt.Errorf("expected map, got %v", val)
 	}
-	return a.AsMap(val), nil
+	return val.AsMapInto(a), nil
 }
 
-func keyedAssociativeListItemToPathElement(a *value.ValueFreelist, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func keyedAssociativeListItemToPathElement(a value.Allocator, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	pe := fieldpath.PathElement{}
 	if child.IsNull() {
 		// For now, the keys are required which means that null entries
@@ -191,7 +191,7 @@ func keyedAssociativeListItemToPathElement(a *value.ValueFreelist, list *schema.
 		return pe, errors.New("associative list with keys may not have non-map elements")
 	}
 	keyMap := value.FieldList{}
-	m := a.AsMap(child)
+	m := child.AsMapInto(a)
 	defer a.Free(m)
 	for _, fieldName := range list.Keys {
 		if val, ok := m.Get(fieldName); ok {

typed/merge.go

@@ -312,7 +312,7 @@ func (w *mergingWalker) visitMapItem(t *schema.Map, out map[string]interface{},
 func (w *mergingWalker) visitMapItems(t *schema.Map, lhs, rhs value.Map) (errs ValidationErrors) {
 	out := map[string]interface{}{}
 
-	w.allocator.MapZip(lhs, rhs, value.Unordered, func(key string, lhsValue, rhsValue value.Value) bool {
+	value.MapZipInto(w.allocator, lhs, rhs, value.Unordered, func(key string, lhsValue, rhsValue value.Value) bool {
 		errs = append(errs, w.visitMapItem(t, out, key, lhsValue, rhsValue)...)
 		return true
 	})

typed/remove.go

@@ -44,16 +44,16 @@ func (w *removingWalker) doScalar(t *schema.Scalar) ValidationErrors {
 }
 
 func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
-	l := w.allocator.AsList(w.value)
+	l := w.value.AsListInto(w.allocator)
 	defer w.allocator.Free(l)
 	// If list is null, empty, or atomic just return
 	if l == nil || l.Length() == 0 || t.ElementRelationship == schema.Atomic {
 		return nil
 	}
 
 	var newItems []interface{}
-	iter := l.Range()
-	defer iter.Recycle()
+	iter := l.RangeInto(w.allocator)
+	defer w.allocator.Free(iter)
 	for iter.Next() {
 		i, item := iter.Item()
 		// Ignore error because we have already validated this list
@@ -74,7 +74,7 @@ func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
 }
 
 func (w *removingWalker) doMap(t *schema.Map) ValidationErrors {
-	m := w.allocator.AsMap(w.value)
+	m := w.value.AsMapInto(w.allocator)
 	if m != nil {
 		defer w.allocator.Free(m)
 	}

typed/validate.go

@@ -116,7 +116,7 @@ func (v *validatingObjectWalker) doScalar(t *schema.Scalar) ValidationErrors {
 func (v *validatingObjectWalker) visitListItems(t *schema.List, list value.List) (errs ValidationErrors) {
 	observedKeys := fieldpath.MakePathElementSet(list.Length())
 	for i := 0; i < list.Length(); i++ {
-		child := v.allocator.At(list, i)
+		child := list.AtInto(v.allocator, i)
 		defer v.allocator.Free(child)
 		var pe fieldpath.PathElement
 		if t.ElementRelationship != schema.Associative {
@@ -161,7 +161,7 @@ func (v *validatingObjectWalker) doList(t *schema.List) (errs ValidationErrors)
 }
 
 func (v *validatingObjectWalker) visitMapItems(t *schema.Map, m value.Map) (errs ValidationErrors) {
-	v.allocator.Iterate(m, func(key string, val value.Value) bool {
+	m.IterateInto(v.allocator, func(key string, val value.Value) bool {
 		pe := fieldpath.PathElement{FieldName: &key}
 		tr := t.ElementType
 		if sf, ok := t.FindField(key); ok {

value/list.go

@@ -23,14 +23,15 @@ type List interface {
 	// At returns the item at the given position in the map. It will
 	// panic if the index is out of range.
 	At(int) Value
-	atInto(Allocator, int) Value
+	AtInto(Allocator, int) Value
 	// Range returns a ListRange for iterating over the items in the list.
 	Range() ListRange
+	RangeInto(Allocator) ListRange
 
 	// Equals compares the two list, and return true if they are the same, false otherwise.
 	// Implementations can use ListEquals as a general implementation for this methods.
 	Equals(List) bool
-	equalsInto(Allocator, List) bool
+	EqualsInto(Allocator, List) bool
 }
 
 // ListRange represents a single iteration across the items of a list.
@@ -42,9 +43,6 @@ type ListRange interface {
 	// pointers to the value returned by Item() that escape the iteration loop since they become invalid once either
 	// Item() or Recycle() is called.
 	Item() (index int, value Value)
-	// Recycle gives back this ListRange once it is no longer needed. The value returned by Item() becomes invalid once this is
-	// called.
-	Recycle()
 }
 
 var EmptyRange = &emptyRange{}
@@ -72,10 +70,10 @@ func listEqualsInto(a Allocator, lhs, rhs List) bool {
 		return false
 	}
 
-	lhsRange := lhs.Range()
-	defer lhsRange.Recycle()
-	rhsRange := rhs.Range()
-	defer rhsRange.Recycle()
+	lhsRange := lhs.RangeInto(a)
+	defer a.Free(lhsRange)
+	rhsRange := rhs.RangeInto(a)
+	defer a.Free(rhsRange)
 
 	for lhsRange.Next() && rhsRange.Next() {
 		_, lv := lhsRange.Item()
@@ -98,10 +96,10 @@ func ListCompare(lhs, rhs List) int {
 	return listCompareInto(defaultAllocator, lhs, rhs)
 }
 func listCompareInto(a Allocator, lhs, rhs List) int {
-	lhsRange := lhs.Range()
-	defer lhsRange.Recycle()
-	rhsRange := rhs.Range()
-	defer rhsRange.Recycle()
+	lhsRange := lhs.RangeInto(a)
+	defer a.Free(lhsRange)
+	rhsRange := rhs.RangeInto(a)
+	defer a.Free(rhsRange)
 
 	for {
 		lhsOk := lhsRange.Next()

value/listreflect.go

@@ -18,7 +18,6 @@ package value
 
 import (
 	"reflect"
-	"sync"
 )
 
 type listReflect struct {
@@ -35,7 +34,7 @@ func (r listReflect) At(i int) Value {
 	return mustWrapValueReflect(val.Index(i), nil, nil)
 }
 
-func (r listReflect) atInto(a Allocator, i int) Value {
+func (r listReflect) AtInto(a Allocator, i int) Value {
 	val := r.Value
 	return a.allocValueReflect().mustReuse(val.Index(i), nil, nil, nil)
 }
@@ -49,28 +48,26 @@ func (r listReflect) Unstructured() interface{} {
 	return result
 }
 
-var lrrPool = sync.Pool{
-	New: func() interface{} {
-		return &listReflectRange{vr: &valueReflect{}}
-	},
+func (r listReflect) Range() ListRange {
+	return r.RangeInto(defaultAllocator)
 }
 
-func (r listReflect) Range() ListRange {
+func (r listReflect) RangeInto(a Allocator) ListRange {
 	length := r.Value.Len()
 	if length == 0 {
 		return EmptyRange
 	}
-	rr := lrrPool.Get().(*listReflectRange)
+	rr := a.allocListReflectRange()
 	rr.list = r.Value
 	rr.i = -1
 	rr.entry = TypeReflectEntryOf(r.Value.Type().Elem())
 	return rr
 }
 
 func (r listReflect) Equals(other List) bool {
-	return r.equalsInto(defaultAllocator, other)
+	return r.EqualsInto(defaultAllocator, other)
 }
-func (r listReflect) equalsInto(a Allocator, other List) bool {
+func (r listReflect) EqualsInto(a Allocator, other List) bool {
 	if otherReflectList, ok := other.(*listReflect); ok {
 		return reflect.DeepEqual(r.Value.Interface(), otherReflectList.Value.Interface())
 	}
@@ -99,7 +96,3 @@ func (r *listReflectRange) Item() (index int, value Value) {
 	v := r.list.Index(r.i)
 	return r.i, r.vr.mustReuse(v, r.entry, nil, nil)
 }
-
-func (r *listReflectRange) Recycle() {
-	lrrPool.Put(r)
-}

value/listunstructured.go

@@ -16,8 +16,6 @@ limitations under the License.
 
 package value
 
-import "sync"
-
 type listUnstructured []interface{}
 
 func (l listUnstructured) Length() int {
@@ -28,33 +26,27 @@ func (l listUnstructured) At(i int) Value {
 	return NewValueInterface(l[i])
 }
 
-func (l listUnstructured) atInto(a Allocator, i int) Value {
+func (l listUnstructured) AtInto(a Allocator, i int) Value {
 	return a.allocValueUnstructured().reuse(l[i])
 }
 
 func (l listUnstructured) Equals(other List) bool {
-	return l.equalsInto(defaultAllocator, other)
+	return l.EqualsInto(defaultAllocator, other)
 }
 
-func (l listUnstructured) equalsInto(a Allocator, other List) bool {
+func (l listUnstructured) EqualsInto(a Allocator, other List) bool {
 	return listEqualsInto(a, &l, other)
 }
 
-var lurPool = sync.Pool{
-	New: func() interface{} {
-		return &listUnstructuredRange{vv: &valueUnstructured{}}
-	},
-}
-
-func (_ listUnstructured) Recycle() {
-
+func (l listUnstructured) Range() ListRange {
+	return l.RangeInto(defaultAllocator)
 }
 
-func (l listUnstructured) Range() ListRange {
+func (l listUnstructured) RangeInto(a Allocator) ListRange {
 	if len(l) == 0 {
 		return EmptyRange
 	}
-	r := lurPool.Get().(*listUnstructuredRange)
+	r := a.allocListUnstructuredRange()
 	r.list = l
 	r.i = -1
 	return r
@@ -80,7 +72,3 @@ func (r *listUnstructuredRange) Item() (index int, value Value) {
 	}
 	return r.i, r.vv.reuse(r.list[r.i])
 }
-
-func (r *listUnstructuredRange) Recycle() {
-	lurPool.Put(r)
-}