add all integer types

feature_any.go

@@ -12,6 +12,9 @@ type Any interface {
 	ToInt() int
 	ToInt32() int32
 	ToInt64() int64
+	ToUint() uint
+	ToUint32() uint32
+	ToUint64() uint64
 	ToFloat32() float32
 	ToFloat64() float64
 	ToString() string
@@ -67,8 +70,20 @@ func (any *baseAny) SetObject(map[string]Any) bool {
 	return false
 }
 
+func WrapInt32(val int32) Any {
+	return &int32Any{baseAny{}, val}
+}
+
 func WrapInt64(val int64) Any {
-	return &intAny{baseAny{}, val}
+	return &int64Any{baseAny{}, val}
+}
+
+func WrapUint32(val uint32) Any {
+	return &uint32Any{baseAny{}, val}
+}
+
+func WrapUint64(val uint64) Any {
+	return &uint64Any{baseAny{}, val}
 }
 
 func WrapFloat64(val float64) Any {
@@ -96,23 +111,23 @@ func Wrap(val interface{}) Any {
 	case reflect.Int:
 		return WrapInt64(int64(val.(int)))
 	case reflect.Int8:
-		return WrapInt64(int64(val.(int8)))
+		return WrapInt32(int32(val.(int8)))
 	case reflect.Int16:
-		return WrapInt64(int64(val.(int16)))
+		return WrapInt32(int32(val.(int16)))
 	case reflect.Int32:
-		return WrapInt64(int64(val.(int32)))
+		return WrapInt32(val.(int32))
 	case reflect.Int64:
 		return WrapInt64(val.(int64))
 	case reflect.Uint:
-		return WrapInt64(int64(val.(uint)))
+		return WrapUint64(uint64(val.(uint)))
 	case reflect.Uint8:
-		return WrapInt64(int64(val.(uint8)))
+		return WrapUint32(uint32(val.(uint8)))
 	case reflect.Uint16:
-		return WrapInt64(int64(val.(uint16)))
+		return WrapUint32(uint32(val.(uint16)))
 	case reflect.Uint32:
-		return WrapInt64(int64(val.(uint32)))
+		return WrapUint32(uint32(val.(uint32)))
 	case reflect.Uint64:
-		return WrapInt64(int64(val.(uint64)))
+		return WrapUint64(val.(uint64))
 	case reflect.Float32:
 		return WrapFloat64(float64(val.(float32)))
 	case reflect.Float64:
@@ -150,14 +165,14 @@ func (iter *Iterator) readAny(reusableIter *Iterator) Any {
 	case '[':
 		return iter.readArrayAny(reusableIter)
 	default:
-		iter.unreadByte()
-		return iter.readNumberAny(reusableIter)
+		return iter.readNumberAny(reusableIter, c)
 	}
 }
 
-func (iter *Iterator) readNumberAny(reusableIter *Iterator) Any {
+func (iter *Iterator) readNumberAny(reusableIter *Iterator, firstByte byte) Any {
 	dotFound := false
-	var lazyBuf []byte
+	lazyBuf := make([]byte, 1, 8)
+	lazyBuf[0] = firstByte
 	for {
 		for i := iter.head; i < iter.tail; i++ {
 			c := iter.buf[i]
@@ -170,9 +185,13 @@ func (iter *Iterator) readNumberAny(reusableIter *Iterator) Any {
 				lazyBuf = append(lazyBuf, iter.buf[iter.head:i]...)
 				iter.head = i
 				if dotFound {
-					return &floatLazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+					return &float64LazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
 				} else {
-					return &intLazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+					if firstByte == '-' {
+						return &int64LazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+					} else {
+						return &uint64LazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+					}
 				}
 			}
 		}
@@ -180,9 +199,13 @@ func (iter *Iterator) readNumberAny(reusableIter *Iterator) Any {
 		if !iter.loadMore() {
 			iter.head = iter.tail
 			if dotFound {
-				return &floatLazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+				return &float64LazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
 			} else {
-				return &intLazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+				if firstByte == '-' {
+					return &int64LazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+				} else {
+					return &uint64LazyAny{baseAny{}, lazyBuf, reusableIter, nil, 0}
+				}
 			}
 		}
 	}

feature_any_array.go

@@ -146,6 +146,36 @@ func (any *arrayLazyAny) ToInt64() int64 {
 	return 1
 }
 
+func (any *arrayLazyAny) ToUint() uint {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *arrayLazyAny) ToUint32() uint32 {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *arrayLazyAny) ToUint64() uint64 {
+	if any.cache == nil {
+		any.IterateArray() // trigger first element read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
 func (any *arrayLazyAny) ToFloat32() float32 {
 	if any.cache == nil {
 		any.IterateArray() // trigger first element read
@@ -315,57 +345,60 @@ func (any *arrayAny) LastError() error {
 }
 
 func (any *arrayAny) ToBool() bool {
-	if any.cache == nil {
-		any.IterateArray() // trigger first element read
-	}
-	return len(any.cache) != 0
+	return any.val.Len() != 0
 }
 
 func (any *arrayAny) ToInt() int {
-	if any.cache == nil {
-		any.IterateArray() // trigger first element read
-	}
-	if len(any.cache) == 0 {
+	if any.val.Len() == 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 {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1
 }
 
 func (any *arrayAny) ToInt64() int64 {
-	if any.cache == nil {
-		any.IterateArray() // trigger first element read
+	if any.val.Len() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *arrayAny) ToUint() uint {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1
 }
 
-func (any *arrayAny) ToFloat32() float32 {
-	if any.cache == nil {
-		any.IterateArray() // trigger first element read
+func (any *arrayAny) ToUint32() uint32 {
+	if any.val.Len() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *arrayAny) ToUint64() uint64 {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1
 }
 
-func (any *arrayAny) ToFloat64() float64 {
-	if any.cache == nil {
-		any.IterateArray() // trigger first element read
+func (any *arrayAny) ToFloat32() float32 {
+	if any.val.Len() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *arrayAny) ToFloat64() float64 {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1

feature_any_bool.go

@@ -24,6 +24,18 @@ func (any *trueAny) ToInt64() int64 {
 	return 1
 }
 
+func (any *trueAny) ToUint() uint {
+	return 1
+}
+
+func (any *trueAny) ToUint32() uint32 {
+	return 1
+}
+
+func (any *trueAny) ToUint64() uint64 {
+	return 1
+}
+
 func (any *trueAny) ToFloat32() float32 {
 	return 1
 }
@@ -76,6 +88,18 @@ func (any *falseAny) ToInt64() int64 {
 	return 0
 }
 
+func (any *falseAny) ToUint() uint {
+	return 0
+}
+
+func (any *falseAny) ToUint32() uint32 {
+	return 0
+}
+
+func (any *falseAny) ToUint64() uint64 {
+	return 0
+}
+
 func (any *falseAny) ToFloat32() float32 {
 	return 0
 }

feature_any_float.go

@@ -6,7 +6,7 @@ import (
 	"strconv"
 )
 
-type floatLazyAny struct {
+type float64LazyAny struct {
 	baseAny
 	buf []byte
 	iter *Iterator
@@ -14,7 +14,7 @@ type floatLazyAny struct {
 	cache float64
 }
 
-func (any *floatLazyAny) Parse() *Iterator {
+func (any *float64LazyAny) Parse() *Iterator {
 	iter := any.iter
 	if iter == nil {
 		iter = NewIterator()
@@ -23,11 +23,11 @@ func (any *floatLazyAny) Parse() *Iterator {
 	return iter
 }
 
-func (any *floatLazyAny) ValueType() ValueType {
+func (any *float64LazyAny) ValueType() ValueType {
 	return Number
 }
 
-func (any *floatLazyAny) fillCache() {
+func (any *float64LazyAny) fillCache() {
 	if any.err != nil {
 		return
 	}
@@ -39,48 +39,63 @@ func (any *floatLazyAny) fillCache() {
 	any.err = iter.Error
 }
 
-func (any *floatLazyAny) LastError() error {
+func (any *float64LazyAny) LastError() error {
 	return any.err
 }
 
-func (any *floatLazyAny) ToBool() bool {
+func (any *float64LazyAny) ToBool() bool {
 	return any.ToFloat64() != 0
 }
 
-func (any *floatLazyAny) ToInt() int {
+func (any *float64LazyAny) ToInt() int {
 	any.fillCache()
 	return int(any.cache)
 }
 
-func (any *floatLazyAny) ToInt32() int32 {
+func (any *float64LazyAny) ToInt32() int32 {
 	any.fillCache()
 	return int32(any.cache)
 }
 
-func (any *floatLazyAny) ToInt64() int64 {
+func (any *float64LazyAny) ToInt64() int64 {
 	any.fillCache()
 	return int64(any.cache)
 }
 
-func (any *floatLazyAny) ToFloat32() float32 {
+func (any *float64LazyAny) ToUint() uint {
+	any.fillCache()
+	return uint(any.cache)
+}
+
+func (any *float64LazyAny) ToUint32() uint32 {
+	any.fillCache()
+	return uint32(any.cache)
+}
+
+func (any *float64LazyAny) ToUint64() uint64 {
+	any.fillCache()
+	return uint64(any.cache)
+}
+
+func (any *float64LazyAny) ToFloat32() float32 {
 	any.fillCache()
 	return float32(any.cache)
 }
 
-func (any *floatLazyAny) ToFloat64() float64 {
+func (any *float64LazyAny) ToFloat64() float64 {
 	any.fillCache()
 	return any.cache
 }
 
-func (any *floatLazyAny) ToString() string {
+func (any *float64LazyAny) ToString() string {
 	return *(*string)(unsafe.Pointer(&any.buf))
 }
 
-func (any *floatLazyAny) WriteTo(stream *Stream) {
+func (any *float64LazyAny) WriteTo(stream *Stream) {
 	stream.Write(any.buf)
 }
 
-func (any *floatLazyAny) GetInterface() interface{} {
+func (any *float64LazyAny) GetInterface() interface{} {
 	any.fillCache()
 	return any.cache
 }
@@ -118,6 +133,18 @@ func (any *floatAny) ToInt64() int64 {
 	return int64(any.val)
 }
 
+func (any *floatAny) ToUint() uint {
+	return uint(any.val)
+}
+
+func (any *floatAny) ToUint32() uint32 {
+	return uint32(any.val)
+}
+
+func (any *floatAny) ToUint64() uint64 {
+	return uint64(any.val)
+}
+
 func (any *floatAny) ToFloat32() float32 {
 	return float32(any.val)
 }

feature_any_int.go

@@ -1,139 +0,0 @@
-package jsoniter
-
-import (
-	"io"
-	"unsafe"
-	"strconv"
-)
-
-type intLazyAny struct {
-	baseAny
-	buf   []byte
-	iter  *Iterator
-	err   error
-	cache int64
-}
-
-func (any *intLazyAny) ValueType() ValueType {
-	return Number
-}
-
-func (any *intLazyAny) Parse() *Iterator {
-	iter := any.iter
-	if iter == nil {
-		iter = NewIterator()
-	}
-	iter.ResetBytes(any.buf)
-	return iter
-}
-
-func (any *intLazyAny) fillCache() {
-	if any.err != nil {
-		return
-	}
-	iter := any.Parse()
-	any.cache = iter.ReadInt64()
-	if iter.Error != io.EOF {
-		iter.reportError("intLazyAny", "there are bytes left")
-	}
-	any.err = iter.Error
-}
-
-func (any *intLazyAny) LastError() error {
-	return any.err
-}
-
-func (any *intLazyAny) ToBool() bool {
-	return any.ToInt64() != 0
-}
-
-func (any *intLazyAny) ToInt() int {
-	any.fillCache()
-	return int(any.cache)
-}
-
-func (any *intLazyAny) ToInt32() int32 {
-	any.fillCache()
-	return int32(any.cache)
-}
-
-func (any *intLazyAny) ToInt64() int64 {
-	any.fillCache()
-	return any.cache
-}
-
-func (any *intLazyAny) ToFloat32() float32 {
-	any.fillCache()
-	return float32(any.cache)
-}
-
-func (any *intLazyAny) ToFloat64() float64 {
-	any.fillCache()
-	return float64(any.cache)
-}
-
-func (any *intLazyAny) ToString() string {
-	return *(*string)(unsafe.Pointer(&any.buf))
-}
-
-func (any *intLazyAny) WriteTo(stream *Stream) {
-	stream.Write(any.buf)
-}
-
-func (any *intLazyAny) GetInterface() interface{} {
-	any.fillCache()
-	return any.cache
-}
-
-type intAny struct {
-	baseAny
-	val int64
-}
-
-func (any *intAny) LastError() error {
-	return nil
-}
-
-func (any *intAny) ValueType() ValueType {
-	return Number
-}
-
-func (any *intAny) ToBool() bool {
-	return any.ToInt64() != 0
-}
-
-func (any *intAny) ToInt() int {
-	return int(any.val)
-}
-
-func (any *intAny) ToInt32() int32 {
-	return int32(any.val)
-}
-
-func (any *intAny) ToInt64() int64 {
-	return any.val
-}
-
-func (any *intAny) ToFloat32() float32 {
-	return float32(any.val)
-}
-
-func (any *intAny) ToFloat64() float64 {
-	return float64(any.val)
-}
-
-func (any *intAny) ToString() string {
-	return strconv.FormatInt(any.val, 10)
-}
-
-func (any *intAny) WriteTo(stream *Stream) {
-	stream.WriteInt64(any.val)
-}
-
-func (any *intAny) Parse() *Iterator {
-	return nil
-}
-
-func (any *intAny) GetInterface() interface{} {
-	return any.val
-}

feature_any_int32.go

@@ -0,0 +1,70 @@
+package jsoniter
+
+import (
+	"strconv"
+)
+
+type int32Any struct {
+	baseAny
+	val int32
+}
+
+func (any *int32Any) LastError() error {
+	return nil
+}
+
+func (any *int32Any) ValueType() ValueType {
+	return Number
+}
+
+func (any *int32Any) ToBool() bool {
+	return any.val != 0
+}
+
+func (any *int32Any) ToInt() int {
+	return int(any.val)
+}
+
+func (any *int32Any) ToInt32() int32 {
+	return any.val
+}
+
+func (any *int32Any) ToInt64() int64 {
+	return int64(any.val)
+}
+
+func (any *int32Any) ToUint() uint {
+	return uint(any.val)
+}
+
+func (any *int32Any) ToUint32() uint32 {
+	return uint32(any.val)
+}
+
+func (any *int32Any) ToUint64() uint64 {
+	return uint64(any.val)
+}
+
+func (any *int32Any) ToFloat32() float32 {
+	return float32(any.val)
+}
+
+func (any *int32Any) ToFloat64() float64 {
+	return float64(any.val)
+}
+
+func (any *int32Any) ToString() string {
+	return strconv.FormatInt(int64(any.val), 10)
+}
+
+func (any *int32Any) WriteTo(stream *Stream) {
+	stream.WriteInt32(any.val)
+}
+
+func (any *int32Any) Parse() *Iterator {
+	return nil
+}
+
+func (any *int32Any) GetInterface() interface{} {
+	return any.val
+}

feature_any_int64.go

@@ -0,0 +1,166 @@
+package jsoniter
+
+import (
+	"io"
+	"unsafe"
+	"strconv"
+)
+
+type int64LazyAny struct {
+	baseAny
+	buf   []byte
+	iter  *Iterator
+	err   error
+	cache int64
+}
+
+func (any *int64LazyAny) ValueType() ValueType {
+	return Number
+}
+
+func (any *int64LazyAny) Parse() *Iterator {
+	iter := any.iter
+	if iter == nil {
+		iter = NewIterator()
+	}
+	iter.ResetBytes(any.buf)
+	return iter
+}
+
+func (any *int64LazyAny) fillCache() {
+	if any.err != nil {
+		return
+	}
+	iter := any.Parse()
+	any.cache = iter.ReadInt64()
+	if iter.Error != io.EOF {
+		iter.reportError("intLazyAny", "there are bytes left")
+	}
+	any.err = iter.Error
+}
+
+func (any *int64LazyAny) LastError() error {
+	return any.err
+}
+
+func (any *int64LazyAny) ToBool() bool {
+	return any.ToInt64() != 0
+}
+
+func (any *int64LazyAny) ToInt() int {
+	any.fillCache()
+	return int(any.cache)
+}
+
+func (any *int64LazyAny) ToInt32() int32 {
+	any.fillCache()
+	return int32(any.cache)
+}
+
+func (any *int64LazyAny) ToInt64() int64 {
+	any.fillCache()
+	return any.cache
+}
+
+func (any *int64LazyAny) ToUint() uint {
+	any.fillCache()
+	return uint(any.cache)
+}
+
+func (any *int64LazyAny) ToUint32() uint32 {
+	any.fillCache()
+	return uint32(any.cache)
+}
+
+func (any *int64LazyAny) ToUint64() uint64 {
+	any.fillCache()
+	return uint64(any.cache)
+}
+
+func (any *int64LazyAny) ToFloat32() float32 {
+	any.fillCache()
+	return float32(any.cache)
+}
+
+func (any *int64LazyAny) ToFloat64() float64 {
+	any.fillCache()
+	return float64(any.cache)
+}
+
+func (any *int64LazyAny) ToString() string {
+	return *(*string)(unsafe.Pointer(&any.buf))
+}
+
+func (any *int64LazyAny) WriteTo(stream *Stream) {
+	stream.Write(any.buf)
+}
+
+func (any *int64LazyAny) GetInterface() interface{} {
+	any.fillCache()
+	return any.cache
+}
+
+type int64Any struct {
+	baseAny
+	val int64
+}
+
+func (any *int64Any) LastError() error {
+	return nil
+}
+
+func (any *int64Any) ValueType() ValueType {
+	return Number
+}
+
+func (any *int64Any) ToBool() bool {
+	return any.val != 0
+}
+
+func (any *int64Any) ToInt() int {
+	return int(any.val)
+}
+
+func (any *int64Any) ToInt32() int32 {
+	return int32(any.val)
+}
+
+func (any *int64Any) ToInt64() int64 {
+	return any.val
+}
+
+func (any *int64Any) ToUint() uint {
+	return uint(any.val)
+}
+
+func (any *int64Any) ToUint32() uint32 {
+	return uint32(any.val)
+}
+
+func (any *int64Any) ToUint64() uint64 {
+	return uint64(any.val)
+}
+
+func (any *int64Any) ToFloat32() float32 {
+	return float32(any.val)
+}
+
+func (any *int64Any) ToFloat64() float64 {
+	return float64(any.val)
+}
+
+func (any *int64Any) ToString() string {
+	return strconv.FormatInt(any.val, 10)
+}
+
+func (any *int64Any) WriteTo(stream *Stream) {
+	stream.WriteInt64(any.val)
+}
+
+func (any *int64Any) Parse() *Iterator {
+	return nil
+}
+
+func (any *int64Any) GetInterface() interface{} {
+	return any.val
+}

feature_any_invalid.go

@@ -31,6 +31,18 @@ func (any *invalidAny) ToInt64() int64 {
 	return 0
 }
 
+func (any *invalidAny) ToUint() uint {
+	return 0
+}
+
+func (any *invalidAny) ToUint32() uint32 {
+	return 0
+}
+
+func (any *invalidAny) ToUint64() uint64 {
+	return 0
+}
+
 func (any *invalidAny) ToFloat32() float32 {
 	return 0
 }

feature_any_nil.go

@@ -28,6 +28,18 @@ func (any *nilAny) ToInt64() int64 {
 	return 0
 }
 
+func (any *nilAny) ToUint() uint {
+	return 0
+}
+
+func (any *nilAny) ToUint32() uint32 {
+	return 0
+}
+
+func (any *nilAny) ToUint64() uint64 {
+	return 0
+}
+
 func (any *nilAny) ToFloat32() float32 {
 	return 0
 }

feature_any_object.go

@@ -148,6 +148,36 @@ func (any *objectLazyAny) ToInt64() int64 {
 	return 1
 }
 
+func (any *objectLazyAny) ToUint() uint {
+	if any.cache == nil {
+		any.IterateObject() // trigger first value read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *objectLazyAny) ToUint32() uint32 {
+	if any.cache == nil {
+		any.IterateObject() // trigger first value read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
+func (any *objectLazyAny) ToUint64() uint64 {
+	if any.cache == nil {
+		any.IterateObject() // trigger first value read
+	}
+	if len(any.cache) == 0 {
+		return 0
+	}
+	return 1
+}
+
 func (any *objectLazyAny) ToFloat32() float32 {
 	if any.cache == nil {
 		any.IterateObject() // trigger first value read
@@ -381,57 +411,60 @@ func (any *objectAny) LastError() error {
 }
 
 func (any *objectAny) ToBool() bool {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
-	}
-	return len(any.cache) != 0
+	return any.val.NumField() != 0
 }
 
 func (any *objectAny) ToInt() int {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
-	}
-	if len(any.cache) == 0 {
+	if any.val.NumField() == 0 {
 		return 0
 	}
 	return 1
 }
 
 func (any *objectAny) ToInt32() int32 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
-	}
-	if len(any.cache) == 0 {
+	if any.val.NumField() == 0 {
 		return 0
 	}
 	return 1
 }
 
 func (any *objectAny) ToInt64() int64 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
+	if any.val.NumField() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *objectAny) ToUint() uint {
+	if any.val.NumField() == 0 {
 		return 0
 	}
 	return 1
 }
 
-func (any *objectAny) ToFloat32() float32 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
+func (any *objectAny) ToUint32() uint32 {
+	if any.val.NumField() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *objectAny) ToUint64() uint64 {
+	if any.val.NumField() == 0 {
 		return 0
 	}
 	return 1
 }
 
-func (any *objectAny) ToFloat64() float64 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
+func (any *objectAny) ToFloat32() float32 {
+	if any.val.NumField() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *objectAny) ToFloat64() float64 {
+	if any.val.NumField() == 0 {
 		return 0
 	}
 	return 1
@@ -598,7 +631,7 @@ func (any *mapAny) fillCache() {
 	if any.cache == nil {
 		any.cache = map[string]Any{}
 	}
-	if len(any.cache) == len(any.val.MapKeys()) {
+	if len(any.cache) == any.val.Len() {
 		return
 	}
 	for _, key := range any.val.MapKeys() {
@@ -613,57 +646,60 @@ func (any *mapAny) LastError() error {
 }
 
 func (any *mapAny) ToBool() bool {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
-	}
-	return len(any.cache) != 0
+	return any.val.Len() != 0
 }
 
 func (any *mapAny) ToInt() int {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
-	}
-	if len(any.cache) == 0 {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1
 }
 
 func (any *mapAny) ToInt32() int32 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
-	}
-	if len(any.cache) == 0 {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1
 }
 
 func (any *mapAny) ToInt64() int64 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
+	if any.val.Len() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *mapAny) ToUint() uint {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1
 }
 
-func (any *mapAny) ToFloat32() float32 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
+func (any *mapAny) ToUint32() uint32 {
+	if any.val.Len() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *mapAny) ToUint64() uint64 {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1
 }
 
-func (any *mapAny) ToFloat64() float64 {
-	if any.cache == nil {
-		any.IterateObject() // trigger first value read
+func (any *mapAny) ToFloat32() float32 {
+	if any.val.Len() == 0 {
+		return 0
 	}
-	if len(any.cache) == 0 {
+	return 1
+}
+
+func (any *mapAny) ToFloat64() float64 {
+	if any.val.Len() == 0 {
 		return 0
 	}
 	return 1

feature_any_string.go

@@ -82,6 +82,30 @@ func (any *stringLazyAny) ToInt64() int64 {
 	return val
 }
 
+func (any *stringLazyAny) ToUint() uint {
+	iter := any.Parse()
+	iter.head++
+	val := iter.ReadUint()
+	any.err = iter.Error
+	return val
+}
+
+func (any *stringLazyAny) ToUint32() uint32 {
+	iter := any.Parse()
+	iter.head++
+	val := iter.ReadUint32()
+	any.err = iter.Error
+	return val
+}
+
+func (any *stringLazyAny) ToUint64() uint64 {
+	iter := any.Parse()
+	iter.head++
+	val := iter.ReadUint64()
+	any.err = iter.Error
+	return val
+}
+
 func (any *stringLazyAny) ToFloat32() float32 {
 	iter := any.Parse()
 	iter.head++
@@ -164,6 +188,24 @@ func (any *stringAny) ToInt64() int64 {
 	return parsed
 }
 
+func (any *stringAny) ToUint() uint {
+	parsed, err := strconv.ParseUint(any.val, 10, 64)
+	any.err = err
+	return uint(parsed)
+}
+
+func (any *stringAny) ToUint32() uint32 {
+	parsed, err := strconv.ParseUint(any.val, 10, 32)
+	any.err = err
+	return uint32(parsed)
+}
+
+func (any *stringAny) ToUint64() uint64 {
+	parsed, err := strconv.ParseUint(any.val, 10, 64)
+	any.err = err
+	return parsed
+}
+
 func (any *stringAny) ToFloat32() float32 {
 	parsed, err := strconv.ParseFloat(any.val, 32)
 	any.err = err

feature_any_uint32.go

@@ -0,0 +1,70 @@
+package jsoniter
+
+import (
+	"strconv"
+)
+
+type uint32Any struct {
+	baseAny
+	val uint32
+}
+
+func (any *uint32Any) LastError() error {
+	return nil
+}
+
+func (any *uint32Any) ValueType() ValueType {
+	return Number
+}
+
+func (any *uint32Any) ToBool() bool {
+	return any.val != 0
+}
+
+func (any *uint32Any) ToInt() int {
+	return int(any.val)
+}
+
+func (any *uint32Any) ToInt32() int32 {
+	return int32(any.val)
+}
+
+func (any *uint32Any) ToInt64() int64 {
+	return int64(any.val)
+}
+
+func (any *uint32Any) ToUint() uint {
+	return uint(any.val)
+}
+
+func (any *uint32Any) ToUint32() uint32 {
+	return any.val
+}
+
+func (any *uint32Any) ToUint64() uint64 {
+	return uint64(any.val)
+}
+
+func (any *uint32Any) ToFloat32() float32 {
+	return float32(any.val)
+}
+
+func (any *uint32Any) ToFloat64() float64 {
+	return float64(any.val)
+}
+
+func (any *uint32Any) ToString() string {
+	return strconv.FormatInt(int64(any.val), 10)
+}
+
+func (any *uint32Any) WriteTo(stream *Stream) {
+	stream.WriteUint32(any.val)
+}
+
+func (any *uint32Any) Parse() *Iterator {
+	return nil
+}
+
+func (any *uint32Any) GetInterface() interface{} {
+	return any.val
+}

feature_any_uint64.go

@@ -0,0 +1,167 @@
+package jsoniter
+
+import (
+	"strconv"
+	"unsafe"
+	"io"
+)
+
+
+type uint64LazyAny struct {
+	baseAny
+	buf   []byte
+	iter  *Iterator
+	err   error
+	cache uint64
+}
+
+func (any *uint64LazyAny) ValueType() ValueType {
+	return Number
+}
+
+func (any *uint64LazyAny) Parse() *Iterator {
+	iter := any.iter
+	if iter == nil {
+		iter = NewIterator()
+	}
+	iter.ResetBytes(any.buf)
+	return iter
+}
+
+func (any *uint64LazyAny) fillCache() {
+	if any.err != nil {
+		return
+	}
+	iter := any.Parse()
+	any.cache = iter.ReadUint64()
+	if iter.Error != io.EOF {
+		iter.reportError("intLazyAny", "there are bytes left")
+	}
+	any.err = iter.Error
+}
+
+func (any *uint64LazyAny) LastError() error {
+	return any.err
+}
+
+func (any *uint64LazyAny) ToBool() bool {
+	return any.ToInt64() != 0
+}
+
+func (any *uint64LazyAny) ToInt() int {
+	any.fillCache()
+	return int(any.cache)
+}
+
+func (any *uint64LazyAny) ToInt32() int32 {
+	any.fillCache()
+	return int32(any.cache)
+}
+
+func (any *uint64LazyAny) ToInt64() int64 {
+	any.fillCache()
+	return int64(any.cache)
+}
+
+func (any *uint64LazyAny) ToUint() uint {
+	any.fillCache()
+	return uint(any.cache)
+}
+
+func (any *uint64LazyAny) ToUint32() uint32 {
+	any.fillCache()
+	return uint32(any.cache)
+}
+
+func (any *uint64LazyAny) ToUint64() uint64 {
+	any.fillCache()
+	return any.cache
+}
+
+func (any *uint64LazyAny) ToFloat32() float32 {
+	any.fillCache()
+	return float32(any.cache)
+}
+
+func (any *uint64LazyAny) ToFloat64() float64 {
+	any.fillCache()
+	return float64(any.cache)
+}
+
+func (any *uint64LazyAny) ToString() string {
+	return *(*string)(unsafe.Pointer(&any.buf))
+}
+
+func (any *uint64LazyAny) WriteTo(stream *Stream) {
+	stream.Write(any.buf)
+}
+
+func (any *uint64LazyAny) GetInterface() interface{} {
+	any.fillCache()
+	return any.cache
+}
+
+type uint64Any struct {
+	baseAny
+	val uint64
+}
+
+func (any *uint64Any) LastError() error {
+	return nil
+}
+
+func (any *uint64Any) ValueType() ValueType {
+	return Number
+}
+
+func (any *uint64Any) ToBool() bool {
+	return any.val != 0
+}
+
+func (any *uint64Any) ToInt() int {
+	return int(any.val)
+}
+
+func (any *uint64Any) ToInt32() int32 {
+	return int32(any.val)
+}
+
+func (any *uint64Any) ToInt64() int64 {
+	return int64(any.val)
+}
+
+func (any *uint64Any) ToUint() uint {
+	return uint(any.val)
+}
+
+func (any *uint64Any) ToUint32() uint32 {
+	return uint32(any.val)
+}
+
+func (any *uint64Any) ToUint64() uint64 {
+	return any.val
+}
+
+func (any *uint64Any) ToFloat32() float32 {
+	return float32(any.val)
+}
+
+func (any *uint64Any) ToFloat64() float64 {
+	return float64(any.val)
+}
+
+func (any *uint64Any) ToString() string {
+	return strconv.FormatUint(any.val, 10)
+}
+
+func (any *uint64Any) WriteTo(stream *Stream) {
+	stream.WriteUint64(any.val)
+}
+
+func (any *uint64Any) Parse() *Iterator {
+	return nil
+}
+
+func (any *uint64Any) GetInterface() interface{} {
+	return any.val
+}