wrap array

feature_any.go

@@ -1,6 +1,9 @@
 package jsoniter
 
-import "fmt"
+import (
+	"fmt"
+	"reflect"
+)
 
 type Any interface {
 	LastError() error
@@ -76,6 +79,41 @@ func WrapString(val string) Any {
 	return &stringAny{baseAny{}, nil, val}
 }
 
+func Wrap(val interface{}) Any {
+	type_ := reflect.TypeOf(val)
+	switch type_.Kind() {
+	case reflect.Slice:
+		return wrapArray(val)
+	case reflect.String:
+		return WrapString(val.(string))
+	case reflect.Int:
+		return WrapInt64(int64(val.(int)))
+	case reflect.Int8:
+		return WrapInt64(int64(val.(int8)))
+	case reflect.Int16:
+		return WrapInt64(int64(val.(int16)))
+	case reflect.Int32:
+		return WrapInt64(int64(val.(int32)))
+	case reflect.Int64:
+		return WrapInt64(val.(int64))
+	case reflect.Uint:
+		return WrapInt64(int64(val.(uint)))
+	case reflect.Uint8:
+		return WrapInt64(int64(val.(uint8)))
+	case reflect.Uint16:
+		return WrapInt64(int64(val.(uint16)))
+	case reflect.Uint32:
+		return WrapInt64(int64(val.(uint32)))
+	case reflect.Uint64:
+		return WrapInt64(int64(val.(uint64)))
+	case reflect.Float32:
+		return WrapFloat64(float64(val.(float32)))
+	case reflect.Float64:
+		return WrapFloat64(val.(float64))
+	}
+	return nil
+}
+
 func (iter *Iterator) ReadAny() Any {
 	return iter.readAny(nil)
 }

feature_any_array.go

@@ -3,6 +3,7 @@ package jsoniter
 import (
 	"unsafe"
 	"fmt"
+	"reflect"
 )
 
 type arrayLazyAny struct {
@@ -288,4 +289,191 @@ func (any *arrayLazyAny) WriteTo(stream *Stream) {
 func (any *arrayLazyAny) GetInterface() interface{} {
 	any.fillCache()
 	return any.cache
+}
+
+type arrayAny struct {
+	baseAny
+	err      error
+	cache    []Any
+	val      reflect.Value
+	parsedTo int
+}
+
+func wrapArray(val interface{}) *arrayAny {
+	return &arrayAny{baseAny{}, nil, nil, reflect.ValueOf(val), 0}
+}
+
+func (any *arrayAny) ValueType() ValueType {
+	return Array
+}
+
+func (any *arrayAny) Parse() *Iterator {
+	return nil
+}
+
+func (any *arrayAny) LastError() error {
+	return any.err
+}
+
+func (any *arrayAny) ToBool() bool {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	return len(any.cache) != 0
+}
+
+func (any *arrayAny) ToInt() int {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *arrayAny) ToInt32() int32 {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *arrayAny) ToInt64() int64 {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *arrayAny) ToFloat32() float32 {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *arrayAny) ToFloat64() float64 {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *arrayAny) ToString() string {
+	if any.parsedTo == 0 {
+		// nothing has been parsed yet
+		str, err := MarshalToString(any.val.Interface())
+		any.err = err
+		return str
+	} else {
+		any.fillCache()
+		str, err := MarshalToString(any.cache)
+		any.err = err
+		return str
+	}
+}
+
+func (any *arrayAny) fillCacheUntil(idx int) Any {
+	if idx < len(any.cache) {
+		return any.cache[idx]
+	} else {
+		for i := any.parsedTo; i < any.val.Len(); i++ {
+			element := Wrap(any.val.Index(i).Interface())
+			any.cache = append(any.cache, element)
+			if idx == i {
+				return element
+			}
+		}
+		return nil
+	}
+}
+
+func (any *arrayAny) fillCache() {
+	any.cache = make([]Any, any.val.Len())
+	for i := 0; i < any.val.Len(); i++ {
+		any.cache[i] = Wrap(any.val.Index(i).Interface())
+	}
+}
+
+func (any *arrayAny) Get(path ...interface{}) Any {
+	if len(path) == 0 {
+		return any
+	}
+	var element Any
+	idx, ok := path[0].(int)
+	if ok {
+		element = any.fillCacheUntil(idx)
+		if element == nil {
+			element = &invalidAny{baseAny{}, fmt.Errorf("%v not found in %v", idx, any.cache)}
+		}
+	} else {
+		element = &invalidAny{baseAny{}, fmt.Errorf("%v not found in %v", idx, any.cache)}
+	}
+	if len(path) == 1 {
+		return element
+	} else {
+		return element.Get(path[1:]...)
+	}
+}
+
+func (any *arrayAny) Size() int {
+	any.fillCache()
+	return len(any.cache)
+}
+
+func (any *arrayAny) IterateArray() (func() (Any, bool), bool) {
+	if any.val.Len() == 0 {
+		return nil, false
+	}
+	i := 0
+	return func() (Any, bool) {
+		if i == any.val.Len() {
+			return nil, false
+		}
+		if i == len(any.cache) {
+			any.cache = append(any.cache, Wrap(any.val.Index(i).Interface()))
+		}
+		val := any.cache[i]
+		i++
+		return val, i != any.val.Len()
+	}, true
+}
+
+func (any *arrayAny) GetArray() []Any {
+	any.fillCache()
+	return any.cache
+}
+
+func (any *arrayAny) SetArray(newList []Any) bool {
+	any.fillCache()
+	any.cache = newList
+	return true
+}
+
+func (any *arrayAny) WriteTo(stream *Stream) {
+	if any.parsedTo == 0 {
+		// nothing has been parsed yet
+		stream.WriteVal(any.val)
+	} else {
+		any.fillCache()
+		stream.WriteVal(any.cache)
+	}
+}
+
+func (any *arrayAny) GetInterface() interface{} {
+	any.fillCache()
+	return any.cache
 }

jsoniter_array_test.go

@@ -82,6 +82,23 @@ func Test_read_array_with_any_iterator(t *testing.T) {
 	should.Equal([]int{1, 2}, elements)
 }
 
+func Test_wrap_array(t *testing.T) {
+	should := require.New(t)
+	any := Wrap([]int{1,2,3})
+	should.Equal("[1,2,3]", any.ToString())
+	var element Any
+	var elements []int
+	for next, hasNext := any.IterateArray(); hasNext; {
+		element, hasNext = next()
+		elements = append(elements, element.ToInt())
+	}
+	should.Equal([]int{1, 2, 3}, elements)
+	any = Wrap([]int{1,2,3})
+	should.Equal(3, any.Size())
+	any = Wrap([]int{1,2,3})
+	should.Equal(2, any.Get(1).ToInt())
+}
+
 func Test_array_lazy_any_get(t *testing.T) {
 	should := require.New(t)
 	any, err := UnmarshalAnyFromString("[1,[2,3],4]")