upgrade reflect2

The use of strconv.FormatFloat causes a string allocation,
by setting aside a reusable buffer and using strconv.AppendFloat
this can be avoided.

Before:
BenchmarkRespond-4           300           5392189 ns/op          618936 B/op      20010 allocs/op

After:
BenchmarkRespond-4           300           4713746 ns/op          139744 B/op         10 allocs/op

This benchmark is using a custom encoder that calls WriteFloat64 20k
times, which is the bulk of the work.

.codecov.yml

@@ -0,0 +1,3 @@
+ignore:
+    - "output_tests/.*"
+

.gitignore

@@ -0,0 +1,4 @@
+/vendor
+/bug_test.go
+/coverage.txt
+/.idea

.travis.yml

@@ -0,0 +1,14 @@
+language: go
+
+go:
+  - 1.8.x
+  - 1.x
+
+before_install:
+  - go get -t -v ./...
+
+script:
+  - ./test.sh
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)

Gopkg.lock

@@ -0,0 +1,45 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/google/gofuzz"
+  packages = ["."]
+  revision = "24818f796faf91cd76ec7bddd72458fbced7a6c1"
+
+[[projects]]
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/stretchr/testify"
+  packages = [
+    "assert",
+    "require"
+  ]
+  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
+  version = "v1.2.1"
+
+[[projects]]
+  name = "github.com/v2pro/plz"
+  packages = [
+    "concurrent",
+    "reflect2"
+  ]
+  revision = "10fc95fad3224a032229e59f6e7023137d82b526"
+  version = "0.9.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "64fe3937a1afce5cb551c06ff7109065c971643e082512243d1071bab428ff14"
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,37 @@
+# Gopkg.toml example
+#
+# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#  name = "github.com/x/y"
+#  version = "2.4.0"
+
+
+[[constraint]]
+  name = "github.com/davecgh/go-spew"
+  version = "1.1.0"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/google/gofuzz"
+
+[[constraint]]
+  name = "github.com/stretchr/testify"
+  version = "1.1.4"
+
+[[constraint]]
+  name = "github.com/v2pro/plz"
+  version = "0.9.1"

README.md

@@ -1,6 +1,18 @@
+[![Sourcegraph](https://sourcegraph.com/github.com/json-iterator/go/-/badge.svg)](https://sourcegraph.com/github.com/json-iterator/go?badge)
+[![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/json-iterator/go)
+[![Build Status](https://travis-ci.org/json-iterator/go.svg?branch=master)](https://travis-ci.org/json-iterator/go)
+[![codecov](https://codecov.io/gh/json-iterator/go/branch/master/graph/badge.svg)](https://codecov.io/gh/json-iterator/go)
 [![rcard](https://goreportcard.com/badge/github.com/json-iterator/go)](https://goreportcard.com/report/github.com/json-iterator/go)
+[![License](http://img.shields.io/badge/license-mit-blue.svg?style=flat-square)](https://raw.githubusercontent.com/json-iterator/go/master/LICENSE)
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/json-iterator/Lobby)
 
-jsoniter (json-iterator) is fast and flexible JSON parser available in [Java](https://github.com/json-iterator/java) and [Go](https://github.com/json-iterator/go)
+A high-performance 100% compatible drop-in replacement of "encoding/json"
+
+You can also use thrift like JSON using [thrift-iterator](https://github.com/thrift-iterator/go)
+
+```
+Go开发者们请加入我们，滴滴出行平台技术部 taowen@didichuxing.com
+```
 
 # Benchmark
 
@@ -34,7 +46,9 @@ with
 
 ```go
 import "github.com/json-iterator/go"
-jsoniter.Marshal(&data)
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+json.Marshal(&data)
 ```
 
 Replace
@@ -48,7 +62,9 @@ with
 
 ```go
 import "github.com/json-iterator/go"
-jsoniter.Unmarshal(input, &data)
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+json.Unmarshal(input, &data)
 ```
 
 [More documentation](http://jsoniter.com/migrate-from-go-std.html)
@@ -61,4 +77,12 @@ go get github.com/json-iterator/go
 
 # Contribution Welcomed !
 
+Contributors
+
+* [thockin](https://github.com/thockin) 
+* [mattn](https://github.com/mattn)
+* [cch123](https://github.com/cch123)
+* [Oleg Shaldybin](https://github.com/olegshaldybin)
+* [Jason Toffaletti](https://github.com/toffaletti)
+
 Report issue or pull request, or email taowen@gmail.com, or [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/json-iterator/Lobby)

adapter.go

@@ -1,14 +1,3 @@
-// Package jsoniter implements encoding and decoding of JSON as defined in
-// RFC 4627 and provides interfaces with identical syntax of standard lib encoding/json.
-// Converting from encoding/json to jsoniter is no more than replacing the package with jsoniter
-// and variable type declarations (if any).
-// jsoniter interfaces gives 100% compatibility with code using standard lib.
-//
-// "JSON and Go"
-// (https://golang.org/doc/articles/json_and_go.html)
-// gives a description of how Marshal/Unmarshal operate
-// between arbitrary or predefined json objects and bytes,
-// and it applies to jsoniter.Marshal/Unmarshal as well.
 package jsoniter
 
 import (
@@ -16,6 +5,7 @@ import (
 	"io"
 )
 
+// RawMessage to make replace json with jsoniter
 type RawMessage []byte
 
 // Unmarshal adapts to json/encoding Unmarshal API
@@ -26,19 +16,12 @@ func Unmarshal(data []byte, v interface{}) error {
 	return ConfigDefault.Unmarshal(data, v)
 }
 
-func lastNotSpacePos(data []byte) int {
-	for i := len(data) - 1; i >= 0; i-- {
-		if data[i] != ' ' && data[i] != '\t' && data[i] != '\r' && data[i] != '\n' {
-			return i + 1
-		}
-	}
-	return 0
-}
-
+// UnmarshalFromString convenient method to read from string instead of []byte
 func UnmarshalFromString(str string, v interface{}) error {
 	return ConfigDefault.UnmarshalFromString(str, v)
 }
 
+// Get quick method to get value from deeply nested JSON structure
 func Get(data []byte, path ...interface{}) Any {
 	return ConfigDefault.Get(data, path...)
 }
@@ -51,6 +34,12 @@ func Marshal(v interface{}) ([]byte, error) {
 	return ConfigDefault.Marshal(v)
 }
 
+// MarshalIndent same as json.MarshalIndent. Prefix is not supported.
+func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
+	return ConfigDefault.MarshalIndent(v, prefix, indent)
+}
+
+// MarshalToString convenient method to write as string instead of []byte
 func MarshalToString(v interface{}) (string, error) {
 	return ConfigDefault.MarshalToString(v)
 }
@@ -71,7 +60,13 @@ type Decoder struct {
 	iter *Iterator
 }
 
+// Decode decode JSON into interface{}
 func (adapter *Decoder) Decode(obj interface{}) error {
+	if adapter.iter.head == adapter.iter.tail && adapter.iter.reader != nil {
+		if !adapter.iter.loadMore() {
+			return io.EOF
+		}
+	}
 	adapter.iter.ReadVal(obj)
 	err := adapter.iter.Error
 	if err == io.EOF {
@@ -80,41 +75,67 @@ func (adapter *Decoder) Decode(obj interface{}) error {
 	return adapter.iter.Error
 }
 
+// More is there more?
 func (adapter *Decoder) More() bool {
 	return adapter.iter.head != adapter.iter.tail
 }
 
+// Buffered remaining buffer
 func (adapter *Decoder) Buffered() io.Reader {
 	remaining := adapter.iter.buf[adapter.iter.head:adapter.iter.tail]
 	return bytes.NewReader(remaining)
 }
 
-func (decoder *Decoder) UseNumber() {
-	origCfg := decoder.iter.cfg.configBeforeFrozen
-	origCfg.UseNumber = true
-	decoder.iter.cfg = origCfg.Froze()
+// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
+// Number instead of as a float64.
+func (adapter *Decoder) UseNumber() {
+	cfg := adapter.iter.cfg.configBeforeFrozen
+	cfg.UseNumber = true
+	adapter.iter.cfg = cfg.frozeWithCacheReuse()
 }
 
+// DisallowUnknownFields causes the Decoder to return an error when the destination
+// is a struct and the input contains object keys which do not match any
+// non-ignored, exported fields in the destination.
+func (adapter *Decoder) DisallowUnknownFields() {
+	cfg := adapter.iter.cfg.configBeforeFrozen
+	cfg.DisallowUnknownFields = true
+	adapter.iter.cfg = cfg.frozeWithCacheReuse()
+}
+
+// NewEncoder same as json.NewEncoder
 func NewEncoder(writer io.Writer) *Encoder {
 	return ConfigDefault.NewEncoder(writer)
 }
 
+// Encoder same as json.Encoder
 type Encoder struct {
 	stream *Stream
 }
 
+// Encode encode interface{} as JSON to io.Writer
 func (adapter *Encoder) Encode(val interface{}) error {
 	adapter.stream.WriteVal(val)
+	adapter.stream.WriteRaw("\n")
 	adapter.stream.Flush()
 	return adapter.stream.Error
 }
 
+// SetIndent set the indention. Prefix is not supported
 func (adapter *Encoder) SetIndent(prefix, indent string) {
-	adapter.stream.cfg.indentionStep = len(indent)
+	config := adapter.stream.cfg.configBeforeFrozen
+	config.IndentionStep = len(indent)
+	adapter.stream.cfg = config.frozeWithCacheReuse()
 }
 
-func (adapter *Encoder) SetEscapeHTML(escapeHtml bool) {
+// SetEscapeHTML escape html by default, set to false to disable
+func (adapter *Encoder) SetEscapeHTML(escapeHTML bool) {
 	config := adapter.stream.cfg.configBeforeFrozen
-	config.EscapeHtml = escapeHtml
-	adapter.stream.cfg = config.Froze()
+	config.EscapeHTML = escapeHTML
+	adapter.stream.cfg = config.frozeWithCacheReuse()
+}
+
+// Valid reports whether data is a valid JSON encoding.
+func Valid(data []byte) bool {
+	return ConfigDefault.Valid(data)
 }

any.go

@@ -1,11 +1,17 @@
 package jsoniter
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"reflect"
+	"unsafe"
+	"github.com/v2pro/plz/reflect2"
+	"strconv"
 )
 
+// Any generic object representation.
+// The lazy json implementation holds []byte and parse lazily.
 type Any interface {
 	LastError() error
 	ValueType() ValueType
@@ -22,13 +28,8 @@ type Any interface {
 	ToString() string
 	ToVal(val interface{})
 	Get(path ...interface{}) Any
-	// TODO: add Set
 	Size() int
 	Keys() []string
-	// TODO: remove me
-	GetArray() []Any
-	// TODO: remove me
-	GetObject() map[string]Any
 	GetInterface() interface{}
 	WriteTo(stream *Stream)
 }
@@ -36,7 +37,7 @@ type Any interface {
 type baseAny struct{}
 
 func (any *baseAny) Get(path ...interface{}) Any {
-	return &invalidAny{baseAny{}, fmt.Errorf("Get %v from simple value", path)}
+	return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)}
 }
 
 func (any *baseAny) Size() int {
@@ -47,42 +48,41 @@ func (any *baseAny) Keys() []string {
 	return []string{}
 }
 
-func (any *baseAny) GetArray() []Any {
-	return []Any{}
-}
-
-func (any *baseAny) GetObject() map[string]Any {
-	return map[string]Any{}
-}
-
 func (any *baseAny) ToVal(obj interface{}) {
 	panic("not implemented")
 }
 
+// WrapInt32 turn int32 into Any interface
 func WrapInt32(val int32) Any {
 	return &int32Any{baseAny{}, val}
 }
 
+// WrapInt64 turn int64 into Any interface
 func WrapInt64(val int64) Any {
 	return &int64Any{baseAny{}, val}
 }
 
+// WrapUint32 turn uint32 into Any interface
 func WrapUint32(val uint32) Any {
 	return &uint32Any{baseAny{}, val}
 }
 
+// WrapUint64 turn uint64 into Any interface
 func WrapUint64(val uint64) Any {
 	return &uint64Any{baseAny{}, val}
 }
 
+// WrapFloat64 turn float64 into Any interface
 func WrapFloat64(val float64) Any {
 	return &floatAny{baseAny{}, val}
 }
 
+// WrapString turn string into Any interface
 func WrapString(val string) Any {
 	return &stringAny{baseAny{}, val}
 }
 
+// Wrap turn a go object into Any interface
 func Wrap(val interface{}) Any {
 	if val == nil {
 		return &nilAny{}
@@ -91,8 +91,8 @@ func Wrap(val interface{}) Any {
 	if isAny {
 		return asAny
 	}
-	type_ := reflect.TypeOf(val)
-	switch type_.Kind() {
+	typ := reflect2.TypeOf(val)
+	switch typ.Kind() {
 	case reflect.Slice:
 		return wrapArray(val)
 	case reflect.Struct:
@@ -102,6 +102,9 @@ func Wrap(val interface{}) Any {
 	case reflect.String:
 		return WrapString(val.(string))
 	case reflect.Int:
+		if strconv.IntSize == 32 {
+			return WrapInt32(int32(val.(int)))
+		}
 		return WrapInt64(int64(val.(int)))
 	case reflect.Int8:
 		return WrapInt32(int32(val.(int8)))
@@ -112,7 +115,15 @@ func Wrap(val interface{}) Any {
 	case reflect.Int64:
 		return WrapInt64(val.(int64))
 	case reflect.Uint:
+		if strconv.IntSize == 32 {
+			return WrapUint32(uint32(val.(uint)))
+		}
 		return WrapUint64(uint64(val.(uint)))
+	case reflect.Uintptr:
+		if ptrSize == 32 {
+			return WrapUint32(uint32(val.(uintptr)))
+		}
+		return WrapUint64(uint64(val.(uintptr)))
 	case reflect.Uint8:
 		return WrapUint32(uint32(val.(uint8)))
 	case reflect.Uint16:
@@ -128,13 +139,13 @@ func Wrap(val interface{}) Any {
 	case reflect.Bool:
 		if val.(bool) == true {
 			return &trueAny{}
-		} else {
-			return &falseAny{}
 		}
+		return &falseAny{}
 	}
-	return &invalidAny{baseAny{}, fmt.Errorf("unsupported type: %v", type_)}
+	return &invalidAny{baseAny{}, fmt.Errorf("unsupported type: %v", typ)}
 }
 
+// ReadAny read next JSON element as an Any object. It is a better json.RawMessage.
 func (iter *Iterator) ReadAny() Any {
 	return iter.readAny()
 }
@@ -146,13 +157,13 @@ func (iter *Iterator) readAny() Any {
 		iter.unreadByte()
 		return &stringAny{baseAny{}, iter.ReadString()}
 	case 'n':
-		iter.skipFixedBytes(3) // null
+		iter.skipThreeBytes('u', 'l', 'l') // null
 		return &nilAny{}
 	case 't':
-		iter.skipFixedBytes(3) // true
+		iter.skipThreeBytes('r', 'u', 'e') // true
 		return &trueAny{}
 	case 'f':
-		iter.skipFixedBytes(4) // false
+		iter.skipFourBytes('a', 'l', 's', 'e') // false
 		return &falseAny{}
 	case '{':
 		return iter.readObjectAny()
@@ -160,6 +171,8 @@ func (iter *Iterator) readAny() Any {
 		return iter.readArrayAny()
 	case '-':
 		return iter.readNumberAny(false)
+	case 0:
+		return &invalidAny{baseAny{}, errors.New("input is empty")}
 	default:
 		return iter.readNumberAny(true)
 	}
@@ -232,9 +245,8 @@ func locatePath(iter *Iterator, path []interface{}) Any {
 		case int32:
 			if '*' == pathKey {
 				return iter.readAny().Get(path[i:]...)
-			} else {
-				return newInvalidAny(path[i:])
 			}
+			return newInvalidAny(path[i:])
 		default:
 			return newInvalidAny(path[i:])
 		}
@@ -244,3 +256,66 @@ func locatePath(iter *Iterator, path []interface{}) Any {
 	}
 	return iter.readAny()
 }
+
+var anyType = reflect2.TypeOfPtr((*Any)(nil)).Elem()
+
+func createDecoderOfAny(ctx *ctx, typ reflect2.Type) ValDecoder {
+	if typ == anyType {
+		return &directAnyCodec{}
+	}
+	if typ.Implements(anyType) {
+		return &anyCodec{
+			valType: typ,
+		}
+	}
+	return nil
+}
+
+func createEncoderOfAny(ctx *ctx, typ reflect2.Type) ValEncoder {
+	if typ == anyType {
+		return &directAnyCodec{}
+	}
+	if typ.Implements(anyType) {
+		return &anyCodec{
+			valType: typ,
+		}
+	}
+	return nil
+}
+
+type anyCodec struct {
+	valType reflect2.Type
+}
+
+func (codec *anyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+	panic("not implemented")
+}
+
+func (codec *anyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+	obj := codec.valType.UnsafeIndirect(ptr)
+	any := obj.(Any)
+	any.WriteTo(stream)
+}
+
+func (codec *anyCodec) IsEmpty(ptr unsafe.Pointer) bool {
+	obj := codec.valType.UnsafeIndirect(ptr)
+	any := obj.(Any)
+	return any.Size() == 0
+}
+
+type directAnyCodec struct {
+}
+
+func (codec *directAnyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+	*(*Any)(ptr) = iter.readAny()
+}
+
+func (codec *directAnyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+	any := *(*Any)(ptr)
+	any.WriteTo(stream)
+}
+
+func (codec *directAnyCodec) IsEmpty(ptr unsafe.Pointer) bool {
+	any := *(*Any)(ptr)
+	return any.Size() == 0
+}

any_array.go

@@ -13,7 +13,7 @@ type arrayLazyAny struct {
 }
 
 func (any *arrayLazyAny) ValueType() ValueType {
-	return Array
+	return ArrayValue
 }
 
 func (any *arrayLazyAny) MustBeValid() Any {
@@ -33,65 +33,57 @@ func (any *arrayLazyAny) ToBool() bool {
 func (any *arrayLazyAny) ToInt() int {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToInt32() int32 {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToInt64() int64 {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToUint() uint {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToUint32() uint32 {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToUint64() uint64 {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToFloat32() float32 {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToFloat64() float64 {
 	if any.ToBool() {
 		return 1
-	} else {
-		return 0
 	}
+	return 0
 }
 
 func (any *arrayLazyAny) ToString() string {
@@ -115,10 +107,9 @@ func (any *arrayLazyAny) Get(path ...interface{}) Any {
 		valueBytes := locateArrayElement(iter, firstPath)
 		if valueBytes == nil {
 			return newInvalidAny(path)
-		} else {
-			iter.ResetBytes(valueBytes)
-			return locatePath(iter, path[1:])
 		}
+		iter.ResetBytes(valueBytes)
+		return locatePath(iter, path[1:])
 	case int32:
 		if '*' == firstPath {
 			iter := any.cfg.BorrowIterator(any.buf)
@@ -126,15 +117,14 @@ func (any *arrayLazyAny) Get(path ...interface{}) Any {
 			arr := make([]Any, 0)
 			iter.ReadArrayCB(func(iter *Iterator) bool {
 				found := iter.readAny().Get(path[1:]...)
-				if found.ValueType() != Invalid {
+				if found.ValueType() != InvalidValue {
 					arr = append(arr, found)
 				}
 				return true
 			})
 			return wrapArray(arr)
-		} else {
-			return newInvalidAny(path)
 		}
+		return newInvalidAny(path)
 	default:
 		return newInvalidAny(path)
 	}
@@ -152,17 +142,6 @@ func (any *arrayLazyAny) Size() int {
 	return size
 }
 
-func (any *arrayLazyAny) GetArray() []Any {
-	elements := make([]Any, 0)
-	iter := any.cfg.BorrowIterator(any.buf)
-	defer any.cfg.ReturnIterator(iter)
-	iter.ReadArrayCB(func(iter *Iterator) bool {
-		elements = append(elements, iter.ReadAny())
-		return true
-	})
-	return elements
-}
-
 func (any *arrayLazyAny) WriteTo(stream *Stream) {
 	stream.Write(any.buf)
 }
@@ -183,7 +162,7 @@ func wrapArray(val interface{}) *arrayAny {
 }
 
 func (any *arrayAny) ValueType() ValueType {
-	return Array
+	return ArrayValue
 }
 
 func (any *arrayAny) MustBeValid() Any {
@@ -274,14 +253,13 @@ func (any *arrayAny) Get(path ...interface{}) Any {
 			mappedAll := make([]Any, 0)
 			for i := 0; i < any.val.Len(); i++ {
 				mapped := Wrap(any.val.Index(i).Interface()).Get(path[1:]...)
-				if mapped.ValueType() != Invalid {
+				if mapped.ValueType() != InvalidValue {
 					mappedAll = append(mappedAll, mapped)
 				}
 			}
 			return wrapArray(mappedAll)
-		} else {
-			return newInvalidAny(path)
 		}
+		return newInvalidAny(path)
 	default:
 		return newInvalidAny(path)
 	}
@@ -291,14 +269,6 @@ func (any *arrayAny) Size() int {
 	return any.val.Len()
 }
 
-func (any *arrayAny) GetArray() []Any {
-	elements := make([]Any, any.val.Len())
-	for i := 0; i < any.val.Len(); i++ {
-		elements[i] = Wrap(any.val.Index(i).Interface())
-	}
-	return elements
-}
-
 func (any *arrayAny) WriteTo(stream *Stream) {
 	stream.WriteVal(any.val)
 }

any_bool.go

@@ -61,7 +61,7 @@ func (any *trueAny) GetInterface() interface{} {
 }
 
 func (any *trueAny) ValueType() ValueType {
-	return Bool
+	return BoolValue
 }
 
 func (any *trueAny) MustBeValid() Any {
@@ -129,7 +129,7 @@ func (any *falseAny) GetInterface() interface{} {
 }
 
 func (any *falseAny) ValueType() ValueType {
-	return Bool
+	return BoolValue
 }
 
 func (any *falseAny) MustBeValid() Any {

any_float.go

@@ -14,7 +14,7 @@ func (any *floatAny) Parse() *Iterator {
 }
 
 func (any *floatAny) ValueType() ValueType {
-	return Number
+	return NumberValue
 }
 
 func (any *floatAny) MustBeValid() Any {
@@ -42,15 +42,24 @@ func (any *floatAny) ToInt64() int64 {
 }
 
 func (any *floatAny) ToUint() uint {
-	return uint(any.val)
+	if any.val > 0 {
+		return uint(any.val)
+	}
+	return 0
 }
 
 func (any *floatAny) ToUint32() uint32 {
-	return uint32(any.val)
+	if any.val > 0 {
+		return uint32(any.val)
+	}
+	return 0
 }
 
 func (any *floatAny) ToUint64() uint64 {
-	return uint64(any.val)
+	if any.val > 0 {
+		return uint64(any.val)
+	}
+	return 0
 }
 
 func (any *floatAny) ToFloat32() float32 {

any_int32.go

@@ -14,7 +14,7 @@ func (any *int32Any) LastError() error {
 }
 
 func (any *int32Any) ValueType() ValueType {
-	return Number
+	return NumberValue
 }
 
 func (any *int32Any) MustBeValid() Any {

any_int64.go

@@ -14,7 +14,7 @@ func (any *int64Any) LastError() error {
 }
 
 func (any *int64Any) ValueType() ValueType {
-	return Number
+	return NumberValue
 }
 
 func (any *int64Any) MustBeValid() Any {

any_invalid.go

@@ -16,12 +16,11 @@ func (any *invalidAny) LastError() error {
 }
 
 func (any *invalidAny) ValueType() ValueType {
-	return Invalid
+	return InvalidValue
 }
 
 func (any *invalidAny) MustBeValid() Any {
 	panic(any.err)
-	return any
 }
 
 func (any *invalidAny) ToBool() bool {
@@ -70,9 +69,8 @@ func (any *invalidAny) WriteTo(stream *Stream) {
 func (any *invalidAny) Get(path ...interface{}) Any {
 	if any.err == nil {
 		return &invalidAny{baseAny{}, fmt.Errorf("get %v from invalid", path)}
-	} else {
-		return &invalidAny{baseAny{}, fmt.Errorf("%v, get %v from invalid", any.err, path)}
 	}
+	return &invalidAny{baseAny{}, fmt.Errorf("%v, get %v from invalid", any.err, path)}
 }
 
 func (any *invalidAny) Parse() *Iterator {

any_nil.go

@@ -9,7 +9,7 @@ func (any *nilAny) LastError() error {
 }
 
 func (any *nilAny) ValueType() ValueType {
-	return Nil
+	return NilValue
 }
 
 func (any *nilAny) MustBeValid() Any {

any_number.go

@@ -1,6 +1,7 @@
 package jsoniter
 
 import (
+	"io"
 	"unsafe"
 )
 
@@ -12,7 +13,7 @@ type numberLazyAny struct {
 }
 
 func (any *numberLazyAny) ValueType() ValueType {
-	return Number
+	return NumberValue
 }
 
 func (any *numberLazyAny) MustBeValid() Any {
@@ -31,7 +32,9 @@ func (any *numberLazyAny) ToInt() int {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadInt()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 
@@ -39,7 +42,9 @@ func (any *numberLazyAny) ToInt32() int32 {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadInt32()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 
@@ -47,7 +52,9 @@ func (any *numberLazyAny) ToInt64() int64 {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadInt64()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 
@@ -55,7 +62,9 @@ func (any *numberLazyAny) ToUint() uint {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadUint()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 
@@ -63,7 +72,9 @@ func (any *numberLazyAny) ToUint32() uint32 {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadUint32()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 
@@ -71,7 +82,9 @@ func (any *numberLazyAny) ToUint64() uint64 {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadUint64()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 
@@ -79,7 +92,9 @@ func (any *numberLazyAny) ToFloat32() float32 {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadFloat32()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 
@@ -87,7 +102,9 @@ func (any *numberLazyAny) ToFloat64() float64 {
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
 	val := iter.ReadFloat64()
-	any.err = iter.Error
+	if iter.Error != nil && iter.Error != io.EOF {
+		any.err = iter.Error
+	}
 	return val
 }
 

any_object.go

@@ -13,7 +13,7 @@ type objectLazyAny struct {
 }
 
 func (any *objectLazyAny) ValueType() ValueType {
-	return Object
+	return ObjectValue
 }
 
 func (any *objectLazyAny) MustBeValid() Any {
@@ -25,73 +25,39 @@ func (any *objectLazyAny) LastError() error {
 }
 
 func (any *objectLazyAny) ToBool() bool {
-	iter := any.cfg.BorrowIterator(any.buf)
-	defer any.cfg.ReturnIterator(iter)
-	return iter.ReadObject() != ""
+	return true
 }
 
 func (any *objectLazyAny) ToInt() int {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToInt32() int32 {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToInt64() int64 {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToUint() uint {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToUint32() uint32 {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToUint64() uint64 {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToFloat32() float32 {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToFloat64() float64 {
-	if any.ToBool() {
-		return 1
-	} else {
-		return 0
-	}
+	return 0
 }
 
 func (any *objectLazyAny) ToString() string {
@@ -115,26 +81,24 @@ func (any *objectLazyAny) Get(path ...interface{}) Any {
 		valueBytes := locateObjectField(iter, firstPath)
 		if valueBytes == nil {
 			return newInvalidAny(path)
-		} else {
-			iter.ResetBytes(valueBytes)
-			return locatePath(iter, path[1:])
 		}
+		iter.ResetBytes(valueBytes)
+		return locatePath(iter, path[1:])
 	case int32:
 		if '*' == firstPath {
 			mappedAll := map[string]Any{}
 			iter := any.cfg.BorrowIterator(any.buf)
 			defer any.cfg.ReturnIterator(iter)
-			iter.ReadObjectCB(func(iter *Iterator, field string) bool {
+			iter.ReadMapCB(func(iter *Iterator, field string) bool {
 				mapped := locatePath(iter, path[1:])
-				if mapped.ValueType() != Invalid {
+				if mapped.ValueType() != InvalidValue {
 					mappedAll[field] = mapped
 				}
 				return true
 			})
 			return wrapMap(mappedAll)
-		} else {
-			return newInvalidAny(path)
 		}
+		return newInvalidAny(path)
 	default:
 		return newInvalidAny(path)
 	}
@@ -144,7 +108,7 @@ func (any *objectLazyAny) Keys() []string {
 	keys := []string{}
 	iter := any.cfg.BorrowIterator(any.buf)
 	defer any.cfg.ReturnIterator(iter)
-	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
+	iter.ReadMapCB(func(iter *Iterator, field string) bool {
 		iter.Skip()
 		keys = append(keys, field)
 		return true
@@ -164,17 +128,6 @@ func (any *objectLazyAny) Size() int {
 	return size
 }
 
-func (any *objectLazyAny) GetObject() map[string]Any {
-	asMap := map[string]Any{}
-	iter := any.cfg.BorrowIterator(any.buf)
-	defer any.cfg.ReturnIterator(iter)
-	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
-		asMap[field] = iter.ReadAny()
-		return true
-	})
-	return asMap
-}
-
 func (any *objectLazyAny) WriteTo(stream *Stream) {
 	stream.Write(any.buf)
 }
@@ -196,7 +149,7 @@ func wrapStruct(val interface{}) *objectAny {
 }
 
 func (any *objectAny) ValueType() ValueType {
-	return Object
+	return ObjectValue
 }
 
 func (any *objectAny) MustBeValid() Any {
@@ -216,59 +169,35 @@ func (any *objectAny) ToBool() bool {
 }
 
 func (any *objectAny) ToInt() int {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToInt32() int32 {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToInt64() int64 {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToUint() uint {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToUint32() uint32 {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToUint64() uint64 {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToFloat32() float32 {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToFloat64() float64 {
-	if any.val.NumField() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *objectAny) ToString() string {
@@ -295,15 +224,14 @@ func (any *objectAny) Get(path ...interface{}) Any {
 				field := any.val.Field(i)
 				if field.CanInterface() {
 					mapped := Wrap(field.Interface()).Get(path[1:]...)
-					if mapped.ValueType() != Invalid {
+					if mapped.ValueType() != InvalidValue {
 						mappedAll[any.val.Type().Field(i).Name] = mapped
 					}
 				}
 			}
 			return wrapMap(mappedAll)
-		} else {
-			return newInvalidAny(path)
 		}
+		return newInvalidAny(path)
 	default:
 		return newInvalidAny(path)
 	}
@@ -321,17 +249,6 @@ func (any *objectAny) Size() int {
 	return any.val.NumField()
 }
 
-func (any *objectAny) GetObject() map[string]Any {
-	object := map[string]Any{}
-	for i := 0; i < any.val.NumField(); i++ {
-		field := any.val.Field(i)
-		if field.CanInterface() {
-			object[any.val.Type().Field(i).Name] = Wrap(field.Interface())
-		}
-	}
-	return object
-}
-
 func (any *objectAny) WriteTo(stream *Stream) {
 	stream.WriteVal(any.val)
 }
@@ -351,7 +268,7 @@ func wrapMap(val interface{}) *mapAny {
 }
 
 func (any *mapAny) ValueType() ValueType {
-	return Object
+	return ObjectValue
 }
 
 func (any *mapAny) MustBeValid() Any {
@@ -367,63 +284,39 @@ func (any *mapAny) LastError() error {
 }
 
 func (any *mapAny) ToBool() bool {
-	return any.val.Len() != 0
+	return true
 }
 
 func (any *mapAny) ToInt() int {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToInt32() int32 {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToInt64() int64 {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToUint() uint {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToUint32() uint32 {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToUint64() uint64 {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToFloat32() float32 {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToFloat64() float64 {
-	if any.val.Len() == 0 {
-		return 0
-	}
-	return 1
+	return 0
 }
 
 func (any *mapAny) ToString() string {
@@ -444,14 +337,13 @@ func (any *mapAny) Get(path ...interface{}) Any {
 				keyAsStr := key.String()
 				element := Wrap(any.val.MapIndex(key).Interface())
 				mapped := element.Get(path[1:]...)
-				if mapped.ValueType() != Invalid {
+				if mapped.ValueType() != InvalidValue {
 					mappedAll[keyAsStr] = mapped
 				}
 			}
 			return wrapMap(mappedAll)
-		} else {
-			return newInvalidAny(path)
 		}
+		return newInvalidAny(path)
 	default:
 		value := any.val.MapIndex(reflect.ValueOf(firstPath))
 		if !value.IsValid() {
@@ -473,16 +365,6 @@ func (any *mapAny) Size() int {
 	return any.val.Len()
 }
 
-func (any *mapAny) GetObject() map[string]Any {
-	object := map[string]Any{}
-	for _, key := range any.val.MapKeys() {
-		keyAsStr := key.String()
-		element := Wrap(any.val.MapIndex(key).Interface())
-		object[keyAsStr] = element
-	}
-	return object
-}
-
 func (any *mapAny) WriteTo(stream *Stream) {
 	stream.WriteVal(any.val)
 }

any_str.go

@@ -0,0 +1,166 @@
+package jsoniter
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type stringAny struct {
+	baseAny
+	val string
+}
+
+func (any *stringAny) Get(path ...interface{}) Any {
+	if len(path) == 0 {
+		return any
+	}
+	return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)}
+}
+
+func (any *stringAny) Parse() *Iterator {
+	return nil
+}
+
+func (any *stringAny) ValueType() ValueType {
+	return StringValue
+}
+
+func (any *stringAny) MustBeValid() Any {
+	return any
+}
+
+func (any *stringAny) LastError() error {
+	return nil
+}
+
+func (any *stringAny) ToBool() bool {
+	str := any.ToString()
+	if str == "0" {
+		return false
+	}
+	for _, c := range str {
+		switch c {
+		case ' ', '\n', '\r', '\t':
+		default:
+			return true
+		}
+	}
+	return false
+}
+
+func (any *stringAny) ToInt() int {
+	return int(any.ToInt64())
+
+}
+
+func (any *stringAny) ToInt32() int32 {
+	return int32(any.ToInt64())
+}
+
+func (any *stringAny) ToInt64() int64 {
+	if any.val == "" {
+		return 0
+	}
+
+	flag := 1
+	startPos := 0
+	endPos := 0
+	if any.val[0] == '+' || any.val[0] == '-' {
+		startPos = 1
+	}
+
+	if any.val[0] == '-' {
+		flag = -1
+	}
+
+	for i := startPos; i < len(any.val); i++ {
+		if any.val[i] >= '0' && any.val[i] <= '9' {
+			endPos = i + 1
+		} else {
+			break
+		}
+	}
+	parsed, _ := strconv.ParseInt(any.val[startPos:endPos], 10, 64)
+	return int64(flag) * parsed
+}
+
+func (any *stringAny) ToUint() uint {
+	return uint(any.ToUint64())
+}
+
+func (any *stringAny) ToUint32() uint32 {
+	return uint32(any.ToUint64())
+}
+
+func (any *stringAny) ToUint64() uint64 {
+	if any.val == "" {
+		return 0
+	}
+
+	startPos := 0
+	endPos := 0
+
+	if any.val[0] == '-' {
+		return 0
+	}
+	if any.val[0] == '+' {
+		startPos = 1
+	}
+
+	for i := startPos; i < len(any.val); i++ {
+		if any.val[i] >= '0' && any.val[i] <= '9' {
+			endPos = i + 1
+		} else {
+			break
+		}
+	}
+	parsed, _ := strconv.ParseUint(any.val[startPos:endPos], 10, 64)
+	return parsed
+}
+
+func (any *stringAny) ToFloat32() float32 {
+	return float32(any.ToFloat64())
+}
+
+func (any *stringAny) ToFloat64() float64 {
+	if len(any.val) == 0 {
+		return 0
+	}
+
+	// first char invalid
+	if any.val[0] != '+' && any.val[0] != '-' && (any.val[0] > '9' || any.val[0] < '0') {
+		return 0
+	}
+
+	// extract valid num expression from string
+	// eg 123true => 123, -12.12xxa => -12.12
+	endPos := 1
+	for i := 1; i < len(any.val); i++ {
+		if any.val[i] == '.' || any.val[i] == 'e' || any.val[i] == 'E' || any.val[i] == '+' || any.val[i] == '-' {
+			endPos = i + 1
+			continue
+		}
+
+		// end position is the first char which is not digit
+		if any.val[i] >= '0' && any.val[i] <= '9' {
+			endPos = i + 1
+		} else {
+			endPos = i
+			break
+		}
+	}
+	parsed, _ := strconv.ParseFloat(any.val[:endPos], 64)
+	return parsed
+}
+
+func (any *stringAny) ToString() string {
+	return any.val
+}
+
+func (any *stringAny) WriteTo(stream *Stream) {
+	stream.WriteString(any.val)
+}
+
+func (any *stringAny) GetInterface() interface{} {
+	return any.val
+}

any_tests/jsoniter_any_array_test.go

@@ -0,0 +1,123 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+func Test_read_empty_array_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[]"))
+	should.Equal(jsoniter.ArrayValue, any.Get().ValueType())
+	should.Equal(jsoniter.InvalidValue, any.Get(0.3).ValueType())
+	should.Equal(0, any.Size())
+	should.Equal(jsoniter.ArrayValue, any.ValueType())
+	should.Nil(any.LastError())
+	should.Equal(0, any.ToInt())
+	should.Equal(int32(0), any.ToInt32())
+	should.Equal(int64(0), any.ToInt64())
+	should.Equal(uint(0), any.ToUint())
+	should.Equal(uint32(0), any.ToUint32())
+	should.Equal(uint64(0), any.ToUint64())
+	should.Equal(float32(0), any.ToFloat32())
+	should.Equal(float64(0), any.ToFloat64())
+}
+
+func Test_read_one_element_array_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[1]"))
+	should.Equal(1, any.Size())
+}
+
+func Test_read_two_element_array_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[1,2]"))
+	should.Equal(1, any.Get(0).ToInt())
+	should.Equal(2, any.Size())
+	should.True(any.ToBool())
+	should.Equal(1, any.ToInt())
+	should.Equal([]interface{}{float64(1), float64(2)}, any.GetInterface())
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("[1,2]", string(stream.Buffer()))
+	arr := []int{}
+	any.ToVal(&arr)
+	should.Equal([]int{1, 2}, arr)
+}
+
+func Test_wrap_array_and_convert_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap([]int{1, 2, 3})
+	any2 := jsoniter.Wrap([]int{})
+
+	should.Equal("[1,2,3]", any.ToString())
+	should.True(any.ToBool())
+	should.False(any2.ToBool())
+
+	should.Equal(1, any.ToInt())
+	should.Equal(0, any2.ToInt())
+	should.Equal(int32(1), any.ToInt32())
+	should.Equal(int32(0), any2.ToInt32())
+	should.Equal(int64(1), any.ToInt64())
+	should.Equal(int64(0), any2.ToInt64())
+	should.Equal(uint(1), any.ToUint())
+	should.Equal(uint(0), any2.ToUint())
+	should.Equal(uint32(1), any.ToUint32())
+	should.Equal(uint32(0), any2.ToUint32())
+	should.Equal(uint64(1), any.ToUint64())
+	should.Equal(uint64(0), any2.ToUint64())
+	should.Equal(float32(1), any.ToFloat32())
+	should.Equal(float32(0), any2.ToFloat32())
+	should.Equal(float64(1), any.ToFloat64())
+	should.Equal(float64(0), any2.ToFloat64())
+	should.Equal(3, any.Size())
+	should.Equal(0, any2.Size())
+
+	var i interface{} = []int{1, 2, 3}
+	should.Equal(i, any.GetInterface())
+}
+
+func Test_array_lazy_any_get(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[1,[2,3],4]"))
+	should.Equal(3, any.Get(1, 1).ToInt())
+	should.Equal("[1,[2,3],4]", any.ToString())
+}
+
+func Test_array_lazy_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[[1],[2],[3,4]]"))
+	should.Equal("[1,2,3]", any.Get('*', 0).ToString())
+	any = jsoniter.Get([]byte("[[[1],[2],[3,4]]]"), 0, '*', 0)
+	should.Equal("[1,2,3]", any.ToString())
+}
+
+func Test_array_wrapper_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap([][]int{
+		{1, 2},
+		{3, 4},
+		{5, 6},
+	})
+	should.Equal("[1,3,5]", any.Get('*', 0).ToString())
+	should.Equal(jsoniter.ArrayValue, any.ValueType())
+	should.True(any.ToBool())
+	should.Equal(1, any.Get(0, 0).ToInt())
+}
+
+func Test_array_lazy_any_get_invalid(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("[]"))
+	should.Equal(jsoniter.InvalidValue, any.Get(1, 1).ValueType())
+	should.NotNil(any.Get(1, 1).LastError())
+	should.Equal(jsoniter.InvalidValue, any.Get("1").ValueType())
+	should.NotNil(any.Get("1").LastError())
+}
+
+func Test_invalid_array(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("["), 0)
+	should.Equal(jsoniter.InvalidValue, any.ValueType())
+}

any_tests/jsoniter_any_bool_test.go

@@ -0,0 +1,65 @@
+package any_tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+var boolConvertMap = map[string]bool{
+	"null":  false,
+	"true":  true,
+	"false": false,
+
+	`"true"`:  true,
+	`"false"`: true,
+
+	"123":   true,
+	`"123"`: true,
+	"0":     false,
+	`"0"`:   false,
+	"-1":    true,
+	`"-1"`:  true,
+
+	"1.1":       true,
+	"0.0":       false,
+	"-1.1":      true,
+	`""`:        false,
+	"[1,2]":     true,
+	"[]":        false,
+	"{}":        true,
+	`{"abc":1}`: true,
+}
+
+func Test_read_bool_as_any(t *testing.T) {
+	should := require.New(t)
+
+	var any jsoniter.Any
+	for k, v := range boolConvertMap {
+		any = jsoniter.Get([]byte(k))
+		if v {
+			should.True(any.ToBool(), fmt.Sprintf("origin val is %v", k))
+		} else {
+			should.False(any.ToBool(), fmt.Sprintf("origin val is %v", k))
+		}
+	}
+
+}
+
+func Test_write_bool_to_stream(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("true"))
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("true", string(stream.Buffer()))
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+
+	any = jsoniter.Get([]byte("false"))
+	stream = jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("false", string(stream.Buffer()))
+
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+}

any_tests/jsoniter_any_float_test.go

@@ -0,0 +1,103 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+var floatConvertMap = map[string]float64{
+	"null":  0,
+	"true":  1,
+	"false": 0,
+
+	`"true"`:  0,
+	`"false"`: 0,
+
+	"1e1":  10,
+	"1e+1": 10,
+	"1e-1": .1,
+	"1E1":  10,
+	"1E+1": 10,
+	"1E-1": .1,
+
+	"-1e1":  -10,
+	"-1e+1": -10,
+	"-1e-1": -.1,
+	"-1E1":  -10,
+	"-1E+1": -10,
+	"-1E-1": -.1,
+
+	`"1e1"`:  10,
+	`"1e+1"`: 10,
+	`"1e-1"`: .1,
+	`"1E1"`:  10,
+	`"1E+1"`: 10,
+	`"1E-1"`: .1,
+
+	`"-1e1"`:  -10,
+	`"-1e+1"`: -10,
+	`"-1e-1"`: -.1,
+	`"-1E1"`:  -10,
+	`"-1E+1"`: -10,
+	`"-1E-1"`: -.1,
+
+	"123":       123,
+	`"123true"`: 123,
+	`"+"`:       0,
+	`"-"`:       0,
+
+	`"-123true"`:  -123,
+	`"-99.9true"`: -99.9,
+	"0":           0,
+	`"0"`:         0,
+	"-1":          -1,
+
+	"1.1":       1.1,
+	"0.0":       0,
+	"-1.1":      -1.1,
+	`"+1.1"`:    1.1,
+	`""`:        0,
+	"[1,2]":     1,
+	"[]":        0,
+	"{}":        0,
+	`{"abc":1}`: 0,
+}
+
+func Test_read_any_to_float(t *testing.T) {
+	should := require.New(t)
+	for k, v := range floatConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(float64(v), any.ToFloat64(), "the original val is "+k)
+	}
+
+	for k, v := range floatConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(float32(v), any.ToFloat32(), "the original val is "+k)
+	}
+}
+
+func Test_read_float_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapFloat64(12.3)
+	anyFloat64 := float64(12.3)
+	//negaAnyFloat64 := float64(-1.1)
+	any2 := jsoniter.WrapFloat64(-1.1)
+	should.Equal(float64(12.3), any.ToFloat64())
+	//should.Equal("12.3", any.ToString())
+	should.True(any.ToBool())
+	should.Equal(float32(anyFloat64), any.ToFloat32())
+	should.Equal(int(anyFloat64), any.ToInt())
+	should.Equal(int32(anyFloat64), any.ToInt32())
+	should.Equal(int64(anyFloat64), any.ToInt64())
+	should.Equal(uint(anyFloat64), any.ToUint())
+	should.Equal(uint32(anyFloat64), any.ToUint32())
+	should.Equal(uint64(anyFloat64), any.ToUint64())
+	should.Equal(uint(0), any2.ToUint())
+	should.Equal(uint32(0), any2.ToUint32())
+	should.Equal(uint64(0), any2.ToUint64())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+
+	should.Equal("1.23E+01", any.ToString())
+}

any_tests/jsoniter_any_int_test.go

@@ -0,0 +1,198 @@
+package any_tests
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+var intConvertMap = map[string]int{
+	"null":       0,
+	"321.1":      321,
+	"-321.1":     -321,
+	`"1.1"`:      1,
+	`"-321.1"`:   -321,
+	"0.0":        0,
+	"0":          0,
+	`"0"`:        0,
+	`"0.0"`:      0,
+	"-1.1":       -1,
+	"true":       1,
+	"false":      0,
+	`"true"`:     0,
+	`"false"`:    0,
+	`"true123"`:  0,
+	`"123true"`:  123,
+	`"-123true"`: -123,
+	`"1.2332e6"`: 1,
+	`""`:         0,
+	"+":          0,
+	"-":          0,
+	"[]":         0,
+	"[1,2]":      1,
+	`["1","2"]`:  1,
+	// object in php cannot convert to int
+	"{}": 0,
+}
+
+func Test_read_any_to_int(t *testing.T) {
+	should := require.New(t)
+
+	// int
+	for k, v := range intConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(v, any.ToInt(), fmt.Sprintf("origin val %v", k))
+	}
+
+	// int32
+	for k, v := range intConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(int32(v), any.ToInt32(), fmt.Sprintf("original val is %v", k))
+	}
+
+	// int64
+	for k, v := range intConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(int64(v), any.ToInt64(), fmt.Sprintf("original val is %v", k))
+	}
+
+}
+
+var uintConvertMap = map[string]int{
+	"null":       0,
+	"321.1":      321,
+	`"1.1"`:      1,
+	`"-123.1"`:   0,
+	"0.0":        0,
+	"0":          0,
+	`"0"`:        0,
+	`"0.0"`:      0,
+	`"00.0"`:     0,
+	"true":       1,
+	"false":      0,
+	`"true"`:     0,
+	`"false"`:    0,
+	`"true123"`:  0,
+	`"+1"`:       1,
+	`"123true"`:  123,
+	`"-123true"`: 0,
+	`"1.2332e6"`: 1,
+	`""`:         0,
+	"+":          0,
+	"-":          0,
+	".":          0,
+	"[]":         0,
+	"[1,2]":      1,
+	"{}":         0,
+	"{1,2}":      0,
+	"-1.1":       0,
+	"-321.1":     0,
+}
+
+func Test_read_any_to_uint(t *testing.T) {
+	should := require.New(t)
+
+	for k, v := range uintConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(uint64(v), any.ToUint64(), fmt.Sprintf("origin val %v", k))
+	}
+
+	for k, v := range uintConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(uint32(v), any.ToUint32(), fmt.Sprintf("origin val %v", k))
+	}
+
+	for k, v := range uintConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(uint(v), any.ToUint(), fmt.Sprintf("origin val %v", k))
+	}
+
+}
+
+func Test_read_int64_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapInt64(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+}
+func Test_read_int32_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapInt32(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+}
+
+func Test_read_uint32_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapUint32(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+}
+
+func Test_read_uint64_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.WrapUint64(12345)
+	should.Equal(12345, any.ToInt())
+	should.Equal(int32(12345), any.ToInt32())
+	should.Equal(int64(12345), any.ToInt64())
+	should.Equal(uint(12345), any.ToUint())
+	should.Equal(uint32(12345), any.ToUint32())
+	should.Equal(uint64(12345), any.ToUint64())
+	should.Equal(float32(12345), any.ToFloat32())
+	should.Equal(float64(12345), any.ToFloat64())
+	should.Equal("12345", any.ToString())
+	should.Equal(true, any.ToBool())
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("12345", string(stream.Buffer()))
+	stream = jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	stream.WriteUint(uint(123))
+	should.Equal("123", string(stream.Buffer()))
+}
+
+func Test_int_lazy_any_get(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("1234"))
+	// panic!!
+	//should.Equal(any.LastError(), io.EOF)
+	should.Equal(jsoniter.InvalidValue, any.Get(1, "2").ValueType())
+}

any_tests/jsoniter_any_map_test.go

@@ -0,0 +1,28 @@
+package any_tests
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+	"github.com/json-iterator/go"
+)
+
+func Test_wrap_map(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap(map[string]string{"Field1": "hello"})
+	should.Equal("hello", any.Get("Field1").ToString())
+	any = jsoniter.Wrap(map[string]string{"Field1": "hello"})
+	should.Equal(1, any.Size())
+}
+
+func Test_map_wrapper_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap(map[string][]int{"Field1": {1, 2}})
+	should.Equal(`{"Field1":1}`, any.Get('*', 0).ToString())
+	should.Contains(any.Keys(), "Field1")
+
+	// map write to
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 0)
+	any.WriteTo(stream)
+	// TODO cannot pass
+	//should.Equal(string(stream.buf), "")
+}

any_tests/jsoniter_any_null_test.go

@@ -1,13 +1,14 @@
-package jsoniter
+package any_tests
 
 import (
-	"github.com/json-iterator/go/require"
+	"github.com/stretchr/testify/require"
 	"testing"
+	"github.com/json-iterator/go"
 )
 
 func Test_read_null_as_any(t *testing.T) {
 	should := require.New(t)
-	any := Get([]byte(`null`))
+	any := jsoniter.Get([]byte(`null`))
 	should.Equal(0, any.ToInt())
 	should.Equal(float64(0), any.ToFloat64())
 	should.Equal("", any.ToString())

any_tests/jsoniter_any_object_test.go

@@ -0,0 +1,123 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+func Test_read_object_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{"a":"stream","c":"d"}`))
+	should.Equal(`{"a":"stream","c":"d"}`, any.ToString())
+	// partial parse
+	should.Equal("stream", any.Get("a").ToString())
+	should.Equal("d", any.Get("c").ToString())
+	should.Equal(2, len(any.Keys()))
+	any = jsoniter.Get([]byte(`{"a":"stream","c":"d"}`))
+	// full parse
+	should.Equal(2, len(any.Keys()))
+	should.Equal(2, any.Size())
+	should.True(any.ToBool())
+	should.Equal(0, any.ToInt())
+	should.Equal(jsoniter.ObjectValue, any.ValueType())
+	should.Nil(any.LastError())
+	obj := struct {
+		A string
+	}{}
+	any.ToVal(&obj)
+	should.Equal("stream", obj.A)
+}
+
+func Test_object_lazy_any_get(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{"a":{"stream":{"c":"d"}}}`))
+	should.Equal("d", any.Get("a", "stream", "c").ToString())
+}
+
+func Test_object_lazy_any_get_all(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{"a":[0],"stream":[1]}`))
+	should.Contains(any.Get('*', 0).ToString(), `"a":0`)
+}
+
+func Test_object_lazy_any_get_invalid(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`{}`))
+	should.Equal(jsoniter.InvalidValue, any.Get("a", "stream", "c").ValueType())
+	should.Equal(jsoniter.InvalidValue, any.Get(1).ValueType())
+}
+
+func Test_wrap_map_and_convert_to_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Wrap(map[string]interface{}{"a": 1})
+	should.True(any.ToBool())
+	should.Equal(0, any.ToInt())
+	should.Equal(int32(0), any.ToInt32())
+	should.Equal(int64(0), any.ToInt64())
+	should.Equal(float32(0), any.ToFloat32())
+	should.Equal(float64(0), any.ToFloat64())
+	should.Equal(uint(0), any.ToUint())
+	should.Equal(uint32(0), any.ToUint32())
+	should.Equal(uint64(0), any.ToUint64())
+}
+
+func Test_wrap_object_and_convert_to_any(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field1 string
+		field2 string
+	}
+	any := jsoniter.Wrap(TestObject{"hello", "world"})
+	should.Equal("hello", any.Get("Field1").ToString())
+	any = jsoniter.Wrap(TestObject{"hello", "world"})
+	should.Equal(2, any.Size())
+	should.Equal(`{"Field1":"hello"}`, any.Get('*').ToString())
+
+	should.Equal(0, any.ToInt())
+	should.Equal(int32(0), any.ToInt32())
+	should.Equal(int64(0), any.ToInt64())
+	should.Equal(float32(0), any.ToFloat32())
+	should.Equal(float64(0), any.ToFloat64())
+	should.Equal(uint(0), any.ToUint())
+	should.Equal(uint32(0), any.ToUint32())
+	should.Equal(uint64(0), any.ToUint64())
+	should.True(any.ToBool())
+	should.Equal(`{"Field1":"hello"}`, any.ToString())
+
+	// cannot pass!
+	//stream := NewStream(ConfigDefault, nil, 32)
+	//any.WriteTo(stream)
+	//should.Equal(`{"Field1":"hello"}`, string(stream.Buffer()))
+	// cannot pass!
+
+}
+
+func Test_any_within_struct(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field1 jsoniter.Any
+		Field2 jsoniter.Any
+	}
+	obj := TestObject{}
+	err := jsoniter.UnmarshalFromString(`{"Field1": "hello", "Field2": [1,2,3]}`, &obj)
+	should.Nil(err)
+	should.Equal("hello", obj.Field1.ToString())
+	should.Equal("[1,2,3]", obj.Field2.ToString())
+}
+
+func Test_object_wrapper_any_get_all(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct {
+		Field1 []int
+		Field2 []int
+	}
+	any := jsoniter.Wrap(TestObject{[]int{1, 2}, []int{3, 4}})
+	should.Contains(any.Get('*', 0).ToString(), `"Field2":3`)
+	should.Contains(any.Keys(), "Field1")
+	should.Contains(any.Keys(), "Field2")
+	should.NotContains(any.Keys(), "Field3")
+
+	//should.Contains(any.GetObject()["Field1"].GetArray()[0], 1)
+}

any_tests/jsoniter_any_string_test.go

@@ -0,0 +1,58 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+var stringConvertMap = map[string]string{
+	"null":      "",
+	"321.1":     "321.1",
+	`"1.1"`:     "1.1",
+	`"-123.1"`:  "-123.1",
+	"0.0":       "0.0",
+	"0":         "0",
+	`"0"`:       "0",
+	`"0.0"`:     "0.0",
+	`"00.0"`:    "00.0",
+	"true":      "true",
+	"false":     "false",
+	`"true"`:    "true",
+	`"false"`:   "false",
+	`"true123"`: "true123",
+	`"+1"`:      "+1",
+	"[]":        "[]",
+	"[1,2]":     "[1,2]",
+	"{}":        "{}",
+	`{"a":1, "stream":true}`: `{"a":1, "stream":true}`,
+}
+
+func Test_read_any_to_string(t *testing.T) {
+	should := require.New(t)
+	for k, v := range stringConvertMap {
+		any := jsoniter.Get([]byte(k))
+		should.Equal(v, any.ToString(), "original val "+k)
+	}
+}
+
+func Test_read_string_as_any(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte(`"hello"`))
+	should.Equal("hello", any.ToString())
+	should.True(any.ToBool())
+	any = jsoniter.Get([]byte(`" "`))
+	should.False(any.ToBool())
+	any = jsoniter.Get([]byte(`"false"`))
+	should.True(any.ToBool())
+	any = jsoniter.Get([]byte(`"123"`))
+	should.Equal(123, any.ToInt())
+}
+
+func Test_wrap_string(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("-32000")).MustBeValid()
+	should.Equal(-32000, any.ToInt())
+	should.NoError(any.LastError())
+}

any_tests/jsoniter_must_be_valid_test.go

@@ -0,0 +1,72 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+// if must be valid is useless, just drop this test
+func Test_must_be_valid(t *testing.T) {
+	should := require.New(t)
+	any := jsoniter.Get([]byte("123"))
+	should.Equal(any.MustBeValid().ToInt(), 123)
+
+	any = jsoniter.Wrap(int8(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(int16(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(int32(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(int64(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint8(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint16(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint32(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(uint64(10))
+	should.Equal(any.MustBeValid().ToInt(), 10)
+
+	any = jsoniter.Wrap(float32(10))
+	should.Equal(any.MustBeValid().ToFloat64(), float64(10))
+
+	any = jsoniter.Wrap(float64(10))
+	should.Equal(any.MustBeValid().ToFloat64(), float64(10))
+
+	any = jsoniter.Wrap(true)
+	should.Equal(any.MustBeValid().ToFloat64(), float64(1))
+
+	any = jsoniter.Wrap(false)
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap(nil)
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap(struct{ age int }{age: 1})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap(map[string]interface{}{"abc": 1})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap("abc")
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap([]int{})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(0))
+
+	any = jsoniter.Wrap([]int{1, 2})
+	should.Equal(any.MustBeValid().ToFloat64(), float64(1))
+}

any_tests/jsoniter_wrap_test.go

@@ -0,0 +1,119 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+func Test_wrap_and_valuetype_everything(t *testing.T) {
+	should := require.New(t)
+	var i interface{}
+	any := jsoniter.Get([]byte("123"))
+	// default of number type is float64
+	i = float64(123)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(int8(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	//  get interface is not int8 interface
+	// i = int8(10)
+	// should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(int16(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	//i = int16(10)
+	//should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(int32(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = int32(10)
+	should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(int64(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = int64(10)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(uint(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	// not equal
+	//i = uint(10)
+	//should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(uint8(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	// not equal
+	// i = uint8(10)
+	// should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(uint16(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	any = jsoniter.Wrap(uint32(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = uint32(10)
+	should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(uint64(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = uint64(10)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(float32(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	// not equal
+	//i = float32(10)
+	//should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(float64(10))
+	should.Equal(any.ValueType(), jsoniter.NumberValue)
+	should.Equal(any.LastError(), nil)
+	i = float64(10)
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(true)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+	should.Equal(any.LastError(), nil)
+	i = true
+	should.Equal(i, any.GetInterface())
+	any = jsoniter.Wrap(false)
+	should.Equal(any.ValueType(), jsoniter.BoolValue)
+	should.Equal(any.LastError(), nil)
+	i = false
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(nil)
+	should.Equal(any.ValueType(), jsoniter.NilValue)
+	should.Equal(any.LastError(), nil)
+	i = nil
+	should.Equal(i, any.GetInterface())
+
+	stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 32)
+	any.WriteTo(stream)
+	should.Equal("null", string(stream.Buffer()))
+	should.Equal(any.LastError(), nil)
+
+	any = jsoniter.Wrap(struct{ age int }{age: 1})
+	should.Equal(any.ValueType(), jsoniter.ObjectValue)
+	should.Equal(any.LastError(), nil)
+	i = struct{ age int }{age: 1}
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap(map[string]interface{}{"abc": 1})
+	should.Equal(any.ValueType(), jsoniter.ObjectValue)
+	should.Equal(any.LastError(), nil)
+	i = map[string]interface{}{"abc": 1}
+	should.Equal(i, any.GetInterface())
+
+	any = jsoniter.Wrap("abc")
+	i = "abc"
+	should.Equal(i, any.GetInterface())
+	should.Equal(nil, any.LastError())
+
+}

any_uint32.go

@@ -14,7 +14,7 @@ func (any *uint32Any) LastError() error {
 }
 
 func (any *uint32Any) ValueType() ValueType {
-	return Number
+	return NumberValue
 }
 
 func (any *uint32Any) MustBeValid() Any {

any_uint64.go

@@ -14,7 +14,7 @@ func (any *uint64Any) LastError() error {
 }
 
 func (any *uint64Any) ValueType() ValueType {
-	return Number
+	return NumberValue
 }
 
 func (any *uint64Any) MustBeValid() Any {

api_tests/config_test.go

@@ -0,0 +1,48 @@
+package test
+
+import (
+	"testing"
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+	"encoding/json"
+)
+
+func Test_use_number_for_unmarshal(t *testing.T) {
+	should := require.New(t)
+	api := jsoniter.Config{UseNumber: true}.Froze()
+	var obj interface{}
+	should.Nil(api.UnmarshalFromString("123", &obj))
+	should.Equal(json.Number("123"), obj)
+}
+
+func Test_customize_float_marshal(t *testing.T) {
+	should := require.New(t)
+	json := jsoniter.Config{MarshalFloatWith6Digits: true}.Froze()
+	str, err := json.MarshalToString(float32(1.23456789))
+	should.Nil(err)
+	should.Equal("1.234568", str)
+}
+
+
+func Test_customize_tag_key(t *testing.T) {
+
+	type TestObject struct {
+		Field string `orm:"field"`
+	}
+
+	should := require.New(t)
+	json := jsoniter.Config{TagKey: "orm"}.Froze()
+	str, err := json.MarshalToString(TestObject{"hello"})
+	should.Nil(err)
+	should.Equal(`{"field":"hello"}`, str)
+}
+
+func Test_read_large_number_as_interface(t *testing.T) {
+	should := require.New(t)
+	var val interface{}
+	err := jsoniter.Config{UseNumber: true}.Froze().UnmarshalFromString(`123456789123456789123456789`, &val)
+	should.Nil(err)
+	output, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Equal(`123456789123456789123456789`, output)
+}

api_tests/decoder_test.go

@@ -1,17 +1,28 @@
-package jsoniter
+package test
 
 import (
 	"bytes"
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"io/ioutil"
+	"github.com/stretchr/testify/require"
 	"testing"
+	"github.com/json-iterator/go"
+	"io/ioutil"
+	"encoding/json"
 )
 
+func Test_disallowUnknownFields(t *testing.T) {
+	should := require.New(t)
+	type TestObject struct{}
+	var obj TestObject
+	decoder := jsoniter.NewDecoder(bytes.NewBufferString(`{"field1":100}`))
+	decoder.DisallowUnknownFields()
+	should.Error(decoder.Decode(&obj))
+}
+
+
 func Test_new_decoder(t *testing.T) {
 	should := require.New(t)
 	decoder1 := json.NewDecoder(bytes.NewBufferString(`[1][2]`))
-	decoder2 := NewDecoder(bytes.NewBufferString(`[1][2]`))
+	decoder2 := jsoniter.NewDecoder(bytes.NewBufferString(`[1][2]`))
 	arr1 := []int{}
 	should.Nil(decoder1.Decode(&arr1))
 	should.Equal([]int{1}, arr1)
@@ -33,25 +44,11 @@ func Test_new_decoder(t *testing.T) {
 	should.False(decoder2.More())
 }
 
-func Test_new_encoder(t *testing.T) {
-	should := require.New(t)
-	buf1 := &bytes.Buffer{}
-	encoder1 := json.NewEncoder(buf1)
-	encoder1.SetEscapeHTML(false)
-	encoder1.Encode([]int{1})
-	should.Equal("[1]\n", buf1.String())
-	buf2 := &bytes.Buffer{}
-	encoder2 := NewEncoder(buf2)
-	encoder2.SetEscapeHTML(false)
-	encoder2.Encode([]int{1})
-	should.Equal("[1]", buf2.String())
-}
-
 func Test_use_number(t *testing.T) {
 	should := require.New(t)
 	decoder1 := json.NewDecoder(bytes.NewBufferString(`123`))
 	decoder1.UseNumber()
-	decoder2 := NewDecoder(bytes.NewBufferString(`123`))
+	decoder2 := jsoniter.NewDecoder(bytes.NewBufferString(`123`))
 	decoder2.UseNumber()
 	var obj1 interface{}
 	should.Nil(decoder1.Decode(&obj1))
@@ -60,11 +57,3 @@ func Test_use_number(t *testing.T) {
 	should.Nil(decoder2.Decode(&obj2))
 	should.Equal(json.Number("123"), obj2)
 }
-
-func Test_use_number_for_unmarshal(t *testing.T) {
-	should := require.New(t)
-	api := Config{UseNumber: true}.Froze()
-	var obj interface{}
-	should.Nil(api.UnmarshalFromString("123", &obj))
-	should.Equal(json.Number("123"), obj)
-}

api_tests/encoder_18_test.go

@@ -0,0 +1,46 @@
+//+build go1.8
+
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+func Test_new_encoder(t *testing.T) {
+	should := require.New(t)
+	buf1 := &bytes.Buffer{}
+	encoder1 := json.NewEncoder(buf1)
+	encoder1.SetEscapeHTML(false)
+	encoder1.Encode([]int{1})
+	should.Equal("[1]\n", buf1.String())
+	buf2 := &bytes.Buffer{}
+	encoder2 := jsoniter.NewEncoder(buf2)
+	encoder2.SetEscapeHTML(false)
+	encoder2.Encode([]int{1})
+	should.Equal("[1]\n", buf2.String())
+}
+
+func Test_string_encode_with_std_without_html_escape(t *testing.T) {
+	api := jsoniter.Config{EscapeHTML: false}.Froze()
+	should := require.New(t)
+	for i := 0; i < utf8.RuneSelf; i++ {
+		input := string([]byte{byte(i)})
+		buf := &bytes.Buffer{}
+		encoder := json.NewEncoder(buf)
+		encoder.SetEscapeHTML(false)
+		err := encoder.Encode(input)
+		should.Nil(err)
+		stdOutput := buf.String()
+		stdOutput = stdOutput[:len(stdOutput)-1]
+		jsoniterOutputBytes, err := api.Marshal(input)
+		should.Nil(err)
+		jsoniterOutput := string(jsoniterOutputBytes)
+		should.Equal(stdOutput, jsoniterOutput)
+	}
+}

api_tests/encoder_test.go

@@ -0,0 +1,20 @@
+package test
+
+import (
+	"testing"
+	"github.com/stretchr/testify/require"
+	"bytes"
+	"github.com/json-iterator/go"
+	"encoding/json"
+)
+
+// Standard Encoder has trailing newline.
+func TestEncoderHasTrailingNewline(t *testing.T) {
+	should := require.New(t)
+	var buf, stdbuf bytes.Buffer
+	enc := jsoniter.ConfigCompatibleWithStandardLibrary.NewEncoder(&buf)
+	enc.Encode(1)
+	stdenc := json.NewEncoder(&stdbuf)
+	stdenc.Encode(1)
+	should.Equal(stdbuf.Bytes(), buf.Bytes())
+}

api_tests/marshal_indent_test.go

@@ -0,0 +1,36 @@
+package test
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"github.com/json-iterator/go"
+)
+
+func Test_marshal_indent(t *testing.T) {
+	should := require.New(t)
+	obj := struct {
+		F1 int
+		F2 []int
+	}{1, []int{2, 3, 4}}
+	output, err := json.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"F1\": 1,\n  \"F2\": [\n    2,\n    3,\n    4\n  ]\n}", string(output))
+	output, err = jsoniter.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"F1\": 1,\n  \"F2\": [\n    2,\n    3,\n    4\n  ]\n}", string(output))
+}
+
+func Test_marshal_indent_map(t *testing.T) {
+	should := require.New(t)
+	obj := map[int]int{1: 2}
+	output, err := json.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"1\": 2\n}", string(output))
+	output, err = jsoniter.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"1\": 2\n}", string(output))
+	output, err = jsoniter.ConfigCompatibleWithStandardLibrary.MarshalIndent(obj, "", "  ")
+	should.Nil(err)
+	should.Equal("{\n  \"1\": 2\n}", string(output))
+}

benchmarks/encode_string_test.go

@@ -0,0 +1,25 @@
+package test
+
+import (
+	"bytes"
+	"github.com/json-iterator/go"
+	"testing"
+)
+
+func Benchmark_encode_string_with_SetEscapeHTML(b *testing.B) {
+	type V struct {
+		S string
+		B bool
+		I int
+	}
+	var json = jsoniter.ConfigCompatibleWithStandardLibrary
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		buf := &bytes.Buffer{}
+		enc := json.NewEncoder(buf)
+		enc.SetEscapeHTML(true)
+		if err := enc.Encode(V{S: "s", B: true, I: 233}); err != nil {
+			b.Fatal(err)
+		}
+	}
+}

benchmarks/jsoniter_large_file_test.go

@@ -0,0 +1,158 @@
+package test
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"testing"
+	"github.com/json-iterator/go"
+)
+
+//func Test_large_file(t *testing.T) {
+//	file, err := os.Open("/tmp/large-file.json")
+//	if err != nil {
+//		t.Fatal(err)
+//	}
+//	iter := Parse(file, 4096)
+//	count := 0
+//	for iter.ReadArray() {
+//		iter.Skip()
+//		count++
+//	}
+//	if count != 11351 {
+//		t.Fatal(count)
+//	}
+//}
+
+func init() {
+	ioutil.WriteFile("/tmp/large-file.json", []byte(`[{
+  "person": {
+    "id": "d50887ca-a6ce-4e59-b89f-14f0b5d03b03",
+    "name": {
+      "fullName": "Leonid Bugaev",
+      "givenName": "Leonid",
+      "familyName": "Bugaev"
+    },
+    "email": "leonsbox@gmail.com",
+    "gender": "male",
+    "location": "Saint Petersburg, Saint Petersburg, RU",
+    "geo": {
+      "city": "Saint Petersburg",
+      "state": "Saint Petersburg",
+      "country": "Russia",
+      "lat": 59.9342802,
+      "lng": 30.3350986
+    },
+    "bio": "Senior engineer at Granify.com",
+    "site": "http://flickfaver.com",
+    "avatar": "https://d1ts43dypk8bqh.cloudfront.net/v1/avatars/d50887ca-a6ce-4e59-b89f-14f0b5d03b03",
+    "employment": {
+      "name": "www.latera.ru",
+      "title": "Software Engineer",
+      "domain": "gmail.com"
+    },
+    "facebook": {
+      "handle": "leonid.bugaev"
+    },
+    "github": {
+      "handle": "buger",
+      "id": 14009,
+      "avatar": "https://avatars.githubusercontent.com/u/14009?v=3",
+      "company": "Granify",
+      "blog": "http://leonsbox.com",
+      "followers": 95,
+      "following": 10
+    },
+    "twitter": {
+      "handle": "flickfaver",
+      "id": 77004410,
+      "bio": null,
+      "followers": 2,
+      "following": 1,
+      "statuses": 5,
+      "favorites": 0,
+      "location": "",
+      "site": "http://flickfaver.com",
+      "avatar": null
+    },
+    "linkedin": {
+      "handle": "in/leonidbugaev"
+    },
+    "googleplus": {
+      "handle": null
+    },
+    "angellist": {
+      "handle": "leonid-bugaev",
+      "id": 61541,
+      "bio": "Senior engineer at Granify.com",
+      "blog": "http://buger.github.com",
+      "site": "http://buger.github.com",
+      "followers": 41,
+      "avatar": "https://d1qb2nb5cznatu.cloudfront.net/users/61541-medium_jpg?1405474390"
+    },
+    "klout": {
+      "handle": null,
+      "score": null
+    },
+    "foursquare": {
+      "handle": null
+    },
+    "aboutme": {
+      "handle": "leonid.bugaev",
+      "bio": null,
+      "avatar": null
+    },
+    "gravatar": {
+      "handle": "buger",
+      "urls": [
+      ],
+      "avatar": "http://1.gravatar.com/avatar/f7c8edd577d13b8930d5522f28123510",
+      "avatars": [
+        {
+          "url": "http://1.gravatar.com/avatar/f7c8edd577d13b8930d5522f28123510",
+          "type": "thumbnail"
+        }
+      ]
+    },
+    "fuzzy": false
+  },
+  "company": "hello"
+}]`), 0666)
+}
+
+/*
+200000	      8886 ns/op	    4336 B/op	       6 allocs/op
+50000	     34244 ns/op	    6744 B/op	      14 allocs/op
+*/
+func Benchmark_jsoniter_large_file(b *testing.B) {
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		file, _ := os.Open("/tmp/large-file.json")
+		iter := jsoniter.Parse(jsoniter.ConfigDefault, file, 4096)
+		count := 0
+		iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
+			// Skip() is strict by default, use --tags jsoniter-sloppy to skip without validation
+			iter.Skip()
+			count++
+			return true
+		})
+		file.Close()
+		if iter.Error != nil {
+			b.Error(iter.Error)
+		}
+	}
+}
+
+func Benchmark_json_large_file(b *testing.B) {
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		file, _ := os.Open("/tmp/large-file.json")
+		bytes, _ := ioutil.ReadAll(file)
+		file.Close()
+		result := []struct{}{}
+		err := json.Unmarshal(bytes, &result)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}

build.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+set -x
+
+if [ ! -d /tmp/build-golang/src/github.com/json-iterator ]; then
+    mkdir -p /tmp/build-golang/src/github.com/json-iterator
+    ln -s $PWD /tmp/build-golang/src/github.com/json-iterator/go
+fi
+export GOPATH=/tmp/build-golang
+go get -u github.com/golang/dep/cmd/dep
+cd /tmp/build-golang/src/github.com/json-iterator/go
+exec $GOPATH/bin/dep ensure -update

config.go

@@ -0,0 +1,302 @@
+package jsoniter
+
+import (
+	"encoding/json"
+	"io"
+	"unsafe"
+	"github.com/v2pro/plz/reflect2"
+	"sync"
+)
+
+// Config customize how the API should behave.
+// The API is created from Config by Froze.
+type Config struct {
+	IndentionStep                 int
+	MarshalFloatWith6Digits       bool
+	EscapeHTML                    bool
+	SortMapKeys                   bool
+	UseNumber                     bool
+	DisallowUnknownFields         bool
+	TagKey                        string
+	OnlyTaggedField               bool
+	ValidateJsonRawMessage        bool
+	ObjectFieldMustBeSimpleString bool
+}
+
+// API the public interface of this package.
+// Primary Marshal and Unmarshal.
+type API interface {
+	IteratorPool
+	StreamPool
+	MarshalToString(v interface{}) (string, error)
+	Marshal(v interface{}) ([]byte, error)
+	MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
+	UnmarshalFromString(str string, v interface{}) error
+	Unmarshal(data []byte, v interface{}) error
+	Get(data []byte, path ...interface{}) Any
+	NewEncoder(writer io.Writer) *Encoder
+	NewDecoder(reader io.Reader) *Decoder
+	Valid(data []byte) bool
+	RegisterExtension(extension Extension)
+}
+
+// ConfigDefault the default API
+var ConfigDefault = Config{
+	EscapeHTML: true,
+}.Froze()
+
+// ConfigCompatibleWithStandardLibrary tries to be 100% compatible with standard library behavior
+var ConfigCompatibleWithStandardLibrary = Config{
+	EscapeHTML:             true,
+	SortMapKeys:            true,
+	ValidateJsonRawMessage: true,
+}.Froze()
+
+// ConfigFastest marshals float with only 6 digits precision
+var ConfigFastest = Config{
+	EscapeHTML:                    false,
+	MarshalFloatWith6Digits:       true, // will lose precession
+	ObjectFieldMustBeSimpleString: true, // do not unescape object field
+}.Froze()
+
+// Froze forge API from config
+func (cfg Config) Froze() API {
+	api := &frozenConfig{
+		sortMapKeys:                   cfg.SortMapKeys,
+		indentionStep:                 cfg.IndentionStep,
+		objectFieldMustBeSimpleString: cfg.ObjectFieldMustBeSimpleString,
+		onlyTaggedField:               cfg.OnlyTaggedField,
+		disallowUnknownFields:         cfg.DisallowUnknownFields,
+	}
+	api.streamPool = &sync.Pool{
+		New: func() interface{} {
+			return NewStream(api, nil, 512)
+		},
+	}
+	api.iteratorPool = &sync.Pool{
+		New: func() interface{} {
+			return NewIterator(api)
+		},
+	}
+	api.initCache()
+	encoderExtension := EncoderExtension{}
+	decoderExtension := DecoderExtension{}
+	if cfg.MarshalFloatWith6Digits {
+		api.marshalFloatWith6Digits(encoderExtension)
+	}
+	if cfg.EscapeHTML {
+		api.escapeHTML(encoderExtension)
+	}
+	if cfg.UseNumber {
+		api.useNumber(decoderExtension)
+	}
+	if cfg.ValidateJsonRawMessage {
+		api.validateJsonRawMessage(encoderExtension)
+	}
+	if len(encoderExtension) > 0 {
+		api.extensions = append(api.extensions, encoderExtension)
+	}
+	if len(decoderExtension) > 0 {
+		api.extensions = append(api.extensions, decoderExtension)
+	}
+	api.configBeforeFrozen = cfg
+	return api
+}
+
+func (cfg Config) frozeWithCacheReuse() *frozenConfig {
+	api := getFrozenConfigFromCache(cfg)
+	if api != nil {
+		return api
+	}
+	api = cfg.Froze().(*frozenConfig)
+	addFrozenConfigToCache(cfg, api)
+	return api
+}
+
+func (cfg *frozenConfig) validateJsonRawMessage(extension EncoderExtension) {
+	encoder := &funcEncoder{func(ptr unsafe.Pointer, stream *Stream) {
+		rawMessage := *(*json.RawMessage)(ptr)
+		iter := cfg.BorrowIterator([]byte(rawMessage))
+		iter.Read()
+		if iter.Error != nil {
+			stream.WriteRaw("null")
+		} else {
+			cfg.ReturnIterator(iter)
+			stream.WriteRaw(string(rawMessage))
+		}
+	}, func(ptr unsafe.Pointer) bool {
+		return false
+	}}
+	extension[reflect2.TypeOfPtr((*json.RawMessage)(nil)).Elem()] = encoder
+	extension[reflect2.TypeOfPtr((*RawMessage)(nil)).Elem()] = encoder
+}
+
+func (cfg *frozenConfig) useNumber(extension DecoderExtension) {
+	extension[reflect2.TypeOfPtr((*interface{})(nil)).Elem()] = &funcDecoder{func(ptr unsafe.Pointer, iter *Iterator) {
+		if iter.WhatIsNext() == NumberValue {
+			*((*interface{})(ptr)) = json.Number(iter.readNumberAsString())
+		} else {
+			*((*interface{})(ptr)) = iter.Read()
+		}
+	}}
+}
+func (cfg *frozenConfig) getTagKey() string {
+	tagKey := cfg.configBeforeFrozen.TagKey
+	if tagKey == "" {
+		return "json"
+	}
+	return tagKey
+}
+
+func (cfg *frozenConfig) RegisterExtension(extension Extension) {
+	cfg.extensions = append(cfg.extensions, extension)
+}
+
+type lossyFloat32Encoder struct {
+}
+
+func (encoder *lossyFloat32Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+	stream.WriteFloat32Lossy(*((*float32)(ptr)))
+}
+
+func (encoder *lossyFloat32Encoder) IsEmpty(ptr unsafe.Pointer) bool {
+	return *((*float32)(ptr)) == 0
+}
+
+type lossyFloat64Encoder struct {
+}
+
+func (encoder *lossyFloat64Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+	stream.WriteFloat64Lossy(*((*float64)(ptr)))
+}
+
+func (encoder *lossyFloat64Encoder) IsEmpty(ptr unsafe.Pointer) bool {
+	return *((*float64)(ptr)) == 0
+}
+
+// EnableLossyFloatMarshalling keeps 10**(-6) precision
+// for float variables for better performance.
+func (cfg *frozenConfig) marshalFloatWith6Digits(extension EncoderExtension) {
+	// for better performance
+	extension[reflect2.TypeOfPtr((*float32)(nil)).Elem()] = &lossyFloat32Encoder{}
+	extension[reflect2.TypeOfPtr((*float64)(nil)).Elem()] = &lossyFloat64Encoder{}
+}
+
+type htmlEscapedStringEncoder struct {
+}
+
+func (encoder *htmlEscapedStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+	str := *((*string)(ptr))
+	stream.WriteStringWithHTMLEscaped(str)
+}
+
+func (encoder *htmlEscapedStringEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+	return *((*string)(ptr)) == ""
+}
+
+func (cfg *frozenConfig) escapeHTML(encoderExtension EncoderExtension) {
+	encoderExtension[reflect2.TypeOfPtr((*string)(nil)).Elem()] = &htmlEscapedStringEncoder{}
+}
+
+func (cfg *frozenConfig) cleanDecoders() {
+	typeDecoders = map[string]ValDecoder{}
+	fieldDecoders = map[string]ValDecoder{}
+	*cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
+}
+
+func (cfg *frozenConfig) cleanEncoders() {
+	typeEncoders = map[string]ValEncoder{}
+	fieldEncoders = map[string]ValEncoder{}
+	*cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
+}
+
+func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) {
+	stream := cfg.BorrowStream(nil)
+	defer cfg.ReturnStream(stream)
+	stream.WriteVal(v)
+	if stream.Error != nil {
+		return "", stream.Error
+	}
+	return string(stream.Buffer()), nil
+}
+
+func (cfg *frozenConfig) Marshal(v interface{}) ([]byte, error) {
+	stream := cfg.BorrowStream(nil)
+	defer cfg.ReturnStream(stream)
+	stream.WriteVal(v)
+	if stream.Error != nil {
+		return nil, stream.Error
+	}
+	result := stream.Buffer()
+	copied := make([]byte, len(result))
+	copy(copied, result)
+	return copied, nil
+}
+
+func (cfg *frozenConfig) MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
+	if prefix != "" {
+		panic("prefix is not supported")
+	}
+	for _, r := range indent {
+		if r != ' ' {
+			panic("indent can only be space")
+		}
+	}
+	newCfg := cfg.configBeforeFrozen
+	newCfg.IndentionStep = len(indent)
+	return newCfg.frozeWithCacheReuse().Marshal(v)
+}
+
+func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {
+	data := []byte(str)
+	iter := cfg.BorrowIterator(data)
+	defer cfg.ReturnIterator(iter)
+	iter.ReadVal(v)
+	c := iter.nextToken()
+	if c == 0 {
+		if iter.Error == io.EOF {
+			return nil
+		}
+		return iter.Error
+	}
+	iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
+	return iter.Error
+}
+
+func (cfg *frozenConfig) Get(data []byte, path ...interface{}) Any {
+	iter := cfg.BorrowIterator(data)
+	defer cfg.ReturnIterator(iter)
+	return locatePath(iter, path)
+}
+
+func (cfg *frozenConfig) Unmarshal(data []byte, v interface{}) error {
+	iter := cfg.BorrowIterator(data)
+	defer cfg.ReturnIterator(iter)
+	iter.ReadVal(v)
+	c := iter.nextToken()
+	if c == 0 {
+		if iter.Error == io.EOF {
+			return nil
+		}
+		return iter.Error
+	}
+	iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
+	return iter.Error
+}
+
+func (cfg *frozenConfig) NewEncoder(writer io.Writer) *Encoder {
+	stream := NewStream(cfg, writer, 512)
+	return &Encoder{stream}
+}
+
+func (cfg *frozenConfig) NewDecoder(reader io.Reader) *Decoder {
+	iter := Parse(cfg, reader, 512)
+	return &Decoder{iter}
+}
+
+func (cfg *frozenConfig) Valid(data []byte) bool {
+	iter := cfg.BorrowIterator(data)
+	defer cfg.ReturnIterator(iter)
+	iter.Skip()
+	return iter.Error == nil
+}

config_with_sync_map.go

@@ -0,0 +1,64 @@
+//+build go1.9
+
+package jsoniter
+
+import (
+	"sync"
+)
+
+type frozenConfig struct {
+	configBeforeFrozen            Config
+	sortMapKeys                   bool
+	indentionStep                 int
+	objectFieldMustBeSimpleString bool
+	onlyTaggedField               bool
+	disallowUnknownFields         bool
+	decoderCache                  sync.Map
+	encoderCache                  sync.Map
+	extensions                    []Extension
+	streamPool                    *sync.Pool
+	iteratorPool                  *sync.Pool
+}
+
+func (cfg *frozenConfig) initCache() {
+	cfg.decoderCache = sync.Map{}
+	cfg.encoderCache = sync.Map{}
+}
+
+func (cfg *frozenConfig) addDecoderToCache(cacheKey uintptr, decoder ValDecoder) {
+	cfg.decoderCache.Store(cacheKey, decoder)
+}
+
+func (cfg *frozenConfig) addEncoderToCache(cacheKey uintptr, encoder ValEncoder) {
+	cfg.encoderCache.Store(cacheKey, encoder)
+}
+
+func (cfg *frozenConfig) getDecoderFromCache(cacheKey uintptr) ValDecoder {
+	decoder, found := cfg.decoderCache.Load(cacheKey)
+	if found {
+		return decoder.(ValDecoder)
+	}
+	return nil
+}
+
+func (cfg *frozenConfig) getEncoderFromCache(cacheKey uintptr) ValEncoder {
+	encoder, found := cfg.encoderCache.Load(cacheKey)
+	if found {
+		return encoder.(ValEncoder)
+	}
+	return nil
+}
+
+var cfgCache = &sync.Map{}
+
+func getFrozenConfigFromCache(cfg Config) *frozenConfig {
+	obj, found := cfgCache.Load(cfg)
+	if found {
+		return obj.(*frozenConfig)
+	}
+	return nil
+}
+
+func addFrozenConfigToCache(cfg Config, frozenConfig *frozenConfig) {
+	cfgCache.Store(cfg, frozenConfig)
+}

config_without_sync_map.go

@@ -0,0 +1,70 @@
+//+build !go1.9
+
+package jsoniter
+
+import (
+	"sync"
+)
+
+type frozenConfig struct {
+	configBeforeFrozen            Config
+	sortMapKeys                   bool
+	indentionStep                 int
+	objectFieldMustBeSimpleString bool
+	onlyTaggedField               bool
+	disallowUnknownFields         bool
+	cacheLock                     *sync.RWMutex
+	decoderCache                  map[uintptr]ValDecoder
+	encoderCache                  map[uintptr]ValEncoder
+	extensions                    []Extension
+	streamPool                    *sync.Pool
+	iteratorPool                  *sync.Pool
+}
+
+func (cfg *frozenConfig) initCache() {
+	cfg.cacheLock = &sync.RWMutex{}
+	cfg.decoderCache = map[uintptr]ValDecoder{}
+	cfg.encoderCache = map[uintptr]ValEncoder{}
+}
+
+func (cfg *frozenConfig) addDecoderToCache(cacheKey uintptr, decoder ValDecoder) {
+	cfg.cacheLock.Lock()
+	cfg.decoderCache[cacheKey] = decoder
+	cfg.cacheLock.Unlock()
+}
+
+func (cfg *frozenConfig) addEncoderToCache(cacheKey uintptr, encoder ValEncoder) {
+	cfg.cacheLock.Lock()
+	cfg.encoderCache[cacheKey] = encoder
+	cfg.cacheLock.Unlock()
+}
+
+func (cfg *frozenConfig) getDecoderFromCache(cacheKey uintptr) ValDecoder {
+	cfg.cacheLock.RLock()
+	decoder, _ := cfg.decoderCache[cacheKey].(ValDecoder)
+	cfg.cacheLock.RUnlock()
+	return decoder
+}
+
+func (cfg *frozenConfig) getEncoderFromCache(cacheKey uintptr) ValEncoder {
+	cfg.cacheLock.RLock()
+	encoder, _ := cfg.encoderCache[cacheKey].(ValEncoder)
+	cfg.cacheLock.RUnlock()
+	return encoder
+}
+
+var cfgCacheLock = &sync.RWMutex{}
+var cfgCache = map[Config]*frozenConfig{}
+
+func getFrozenConfigFromCache(cfg Config) *frozenConfig {
+	cfgCacheLock.RLock()
+	frozenConfig := cfgCache[cfg]
+	cfgCacheLock.RUnlock()
+	return frozenConfig
+}
+
+func addFrozenConfigToCache(cfg Config, frozenConfig *frozenConfig) {
+	cfgCacheLock.Lock()
+	cfgCache[cfg] = frozenConfig
+	cfgCacheLock.Unlock()
+}

example_test.go

@@ -1,10 +1,8 @@
-package jsoniter_test
+package jsoniter
 
 import (
 	"fmt"
 	"os"
-
-	"github.com/json-iterator/go"
 )
 
 func ExampleMarshal() {
@@ -18,7 +16,7 @@ func ExampleMarshal() {
 		Name:   "Reds",
 		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
 	}
-	b, err := jsoniter.Marshal(group)
+	b, err := Marshal(group)
 	if err != nil {
 		fmt.Println("error:", err)
 	}
@@ -37,7 +35,7 @@ func ExampleUnmarshal() {
 		Order string
 	}
 	var animals []Animal
-	err := jsoniter.Unmarshal(jsonBlob, &animals)
+	err := Unmarshal(jsonBlob, &animals)
 	if err != nil {
 		fmt.Println("error:", err)
 	}
@@ -46,7 +44,7 @@ func ExampleUnmarshal() {
 	// [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
 }
 
-func ExampleMarshalWithBestPerformance() {
+func ExampleConfigFastest_Marshal() {
 	type ColorGroup struct {
 		ID     int
 		Name   string
@@ -57,8 +55,8 @@ func ExampleMarshalWithBestPerformance() {
 		Name:   "Reds",
 		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
 	}
-	stream := jsoniter.ConfigFastest.BorrowStream(nil)
-	defer jsoniter.ConfigFastest.ReturnStream(stream)
+	stream := ConfigFastest.BorrowStream(nil)
+	defer ConfigFastest.ReturnStream(stream)
 	stream.WriteVal(group)
 	if stream.Error != nil {
 		fmt.Println("error:", stream.Error)
@@ -68,7 +66,7 @@ func ExampleMarshalWithBestPerformance() {
 	// {"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
 }
 
-func ExampleUnmarshalWithBestPerformance() {
+func ExampleConfigFastest_Unmarshal() {
 	var jsonBlob = []byte(`[
 		{"Name": "Platypus", "Order": "Monotremata"},
 		{"Name": "Quoll",    "Order": "Dasyuromorphia"}
@@ -78,8 +76,8 @@ func ExampleUnmarshalWithBestPerformance() {
 		Order string
 	}
 	var animals []Animal
-	iter := jsoniter.ConfigFastest.BorrowIterator(jsonBlob)
-	defer jsoniter.ConfigFastest.ReturnIterator(iter)
+	iter := ConfigFastest.BorrowIterator(jsonBlob)
+	defer ConfigFastest.ReturnIterator(iter)
 	iter.ReadVal(&animals)
 	if iter.Error != nil {
 		fmt.Println("error:", iter.Error)
@@ -89,9 +87,9 @@ func ExampleUnmarshalWithBestPerformance() {
 	// [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
 }
 
-func ExampleOneLine() {
+func ExampleGet() {
 	val := []byte(`{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}`)
-	fmt.Printf(jsoniter.Get(val, "Colors", 0).ToString())
+	fmt.Printf(Get(val, "Colors", 0).ToString())
 	// Output:
 	// Crimson
 }

extension_tests/decoder_test.go

@@ -0,0 +1,101 @@
+package test
+
+import (
+	"testing"
+	"unsafe"
+	"time"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strconv"
+)
+
+func Test_customize_type_decoder(t *testing.T) {
+	t.Skip()
+	jsoniter.RegisterTypeDecoderFunc("time.Time", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		t, err := time.ParseInLocation("2006-01-02 15:04:05", iter.ReadString(), time.UTC)
+		if err != nil {
+			iter.Error = err
+			return
+		}
+		*((*time.Time)(ptr)) = t
+	})
+	//defer jsoniter.ConfigDefault.(*frozenConfig).cleanDecoders()
+	val := time.Time{}
+	err := jsoniter.Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val)
+	if err != nil {
+		t.Fatal(err)
+	}
+	year, month, day := val.Date()
+	if year != 2016 || month != 12 || day != 5 {
+		t.Fatal(val)
+	}
+}
+
+func Test_customize_byte_array_encoder(t *testing.T) {
+	t.Skip()
+	//jsoniter.ConfigDefault.(*frozenConfig).cleanEncoders()
+	should := require.New(t)
+	jsoniter.RegisterTypeEncoderFunc("[]uint8", func(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+		t := *((*[]byte)(ptr))
+		stream.WriteString(string(t))
+	}, nil)
+	//defer jsoniter.ConfigDefault.(*frozenConfig).cleanEncoders()
+	val := []byte("abc")
+	str, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Equal(`"abc"`, str)
+}
+
+func Test_customize_field_decoder(t *testing.T) {
+	type Tom struct {
+		field1 string
+	}
+	jsoniter.RegisterFieldDecoderFunc("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
+	})
+	//defer jsoniter.ConfigDefault.(*frozenConfig).cleanDecoders()
+	tom := Tom{}
+	err := jsoniter.Unmarshal([]byte(`{"field1": 100}`), &tom)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+
+func Test_recursive_empty_interface_customization(t *testing.T) {
+	t.Skip()
+	var obj interface{}
+	jsoniter.RegisterTypeDecoderFunc("interface {}", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		switch iter.WhatIsNext() {
+		case jsoniter.NumberValue:
+			*(*interface{})(ptr) = iter.ReadInt64()
+		default:
+			*(*interface{})(ptr) = iter.Read()
+		}
+	})
+	should := require.New(t)
+	jsoniter.Unmarshal([]byte("[100]"), &obj)
+	should.Equal([]interface{}{int64(100)}, obj)
+}
+
+type MyInterface interface {
+	Hello() string
+}
+
+type MyString string
+
+func (ms MyString) Hello() string {
+	return string(ms)
+}
+
+func Test_read_custom_interface(t *testing.T) {
+	t.Skip()
+	should := require.New(t)
+	var val MyInterface
+	jsoniter.RegisterTypeDecoderFunc("jsoniter.MyInterface", func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		*((*MyInterface)(ptr)) = MyString(iter.ReadString())
+	})
+	err := jsoniter.UnmarshalFromString(`"hello"`, &val)
+	should.Nil(err)
+	should.Equal("hello", val.Hello())
+}

extension_tests/extension_test.go

@@ -0,0 +1,71 @@
+package test
+
+import (
+	"unsafe"
+	"strconv"
+	"testing"
+	"github.com/stretchr/testify/require"
+	"github.com/json-iterator/go"
+)
+
+type TestObject1 struct {
+	Field1 string
+}
+
+type testExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *testExtension) UpdateStructDescriptor(structDescriptor *jsoniter.StructDescriptor) {
+	if structDescriptor.Type.String() != "test.TestObject1" {
+		return
+	}
+	binding := structDescriptor.GetField("Field1")
+	binding.Encoder = &funcEncoder{fun: func(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+		str := *((*string)(ptr))
+		val, _ := strconv.Atoi(str)
+		stream.WriteInt(val)
+	}}
+	binding.Decoder = &funcDecoder{func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
+	}}
+	binding.ToNames = []string{"field-1"}
+	binding.FromNames = []string{"field-1"}
+}
+
+func Test_customize_field_by_extension(t *testing.T) {
+	should := require.New(t)
+	cfg := jsoniter.Config{}.Froze()
+	cfg.RegisterExtension(&testExtension{})
+	obj := TestObject1{}
+	err := cfg.UnmarshalFromString(`{"field-1": 100}`, &obj)
+	should.Nil(err)
+	should.Equal("100", obj.Field1)
+	str, err := cfg.MarshalToString(obj)
+	should.Nil(err)
+	should.Equal(`{"field-1":100}`, str)
+}
+
+type funcDecoder struct {
+	fun jsoniter.DecoderFunc
+}
+
+func (decoder *funcDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	decoder.fun(ptr, iter)
+}
+
+type funcEncoder struct {
+	fun         jsoniter.EncoderFunc
+	isEmptyFunc func(ptr unsafe.Pointer) bool
+}
+
+func (encoder *funcEncoder) Encode(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+	encoder.fun(ptr, stream)
+}
+
+func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+	if encoder.isEmptyFunc == nil {
+		return false
+	}
+	return encoder.isEmptyFunc(ptr)
+}

extra/fuzzy_decoder.go

@@ -2,26 +2,31 @@ package extra
 
 import (
 	"encoding/json"
-	"github.com/json-iterator/go"
+	"io"
 	"math"
 	"reflect"
 	"strings"
 	"unsafe"
+
+	"github.com/json-iterator/go"
+	"github.com/v2pro/plz/reflect2"
 )
 
-const MaxUint = ^uint(0)
-const MaxInt = int(MaxUint >> 1)
-const MinInt = -MaxInt - 1
+const maxUint = ^uint(0)
+const maxInt = int(maxUint >> 1)
+const minInt = -maxInt - 1
 
+// RegisterFuzzyDecoders decode input from PHP with tolerance.
+// It will handle string/number auto conversation, and treat empty [] as empty struct.
 func RegisterFuzzyDecoders() {
 	jsoniter.RegisterExtension(&tolerateEmptyArrayExtension{})
-	jsoniter.RegisterTypeDecoder("string", &FuzzyStringDecoder{})
-	jsoniter.RegisterTypeDecoder("float32", &FuzzyFloat32Decoder{})
-	jsoniter.RegisterTypeDecoder("float64", &FuzzyFloat64Decoder{})
-	jsoniter.RegisterTypeDecoder("int", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("string", &fuzzyStringDecoder{})
+	jsoniter.RegisterTypeDecoder("float32", &fuzzyFloat32Decoder{})
+	jsoniter.RegisterTypeDecoder("float64", &fuzzyFloat64Decoder{})
+	jsoniter.RegisterTypeDecoder("int", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
-			if val > float64(MaxInt) || val < float64(MinInt) {
+			if val > float64(maxInt) || val < float64(minInt) {
 				iter.ReportError("fuzzy decode int", "exceed range")
 				return
 			}
@@ -30,10 +35,10 @@ func RegisterFuzzyDecoders() {
 			*((*int)(ptr)) = iter.ReadInt()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
-			if val > float64(MaxUint) || val < 0 {
+			if val > float64(maxUint) || val < 0 {
 				iter.ReportError("fuzzy decode uint", "exceed range")
 				return
 			}
@@ -42,7 +47,7 @@ func RegisterFuzzyDecoders() {
 			*((*uint)(ptr)) = iter.ReadUint()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int8", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int8", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt8) || val < float64(math.MinInt8) {
@@ -54,7 +59,7 @@ func RegisterFuzzyDecoders() {
 			*((*int8)(ptr)) = iter.ReadInt8()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint8", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint8", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint8) || val < 0 {
@@ -66,7 +71,7 @@ func RegisterFuzzyDecoders() {
 			*((*uint8)(ptr)) = iter.ReadUint8()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int16", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int16", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt16) || val < float64(math.MinInt16) {
@@ -78,7 +83,7 @@ func RegisterFuzzyDecoders() {
 			*((*int16)(ptr)) = iter.ReadInt16()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint16", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint16", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint16) || val < 0 {
@@ -90,7 +95,7 @@ func RegisterFuzzyDecoders() {
 			*((*uint16)(ptr)) = iter.ReadUint16()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int32", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int32", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt32) || val < float64(math.MinInt32) {
@@ -102,7 +107,7 @@ func RegisterFuzzyDecoders() {
 			*((*int32)(ptr)) = iter.ReadInt32()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint32", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint32", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint32) || val < 0 {
@@ -114,7 +119,7 @@ func RegisterFuzzyDecoders() {
 			*((*uint32)(ptr)) = iter.ReadUint32()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("int64", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("int64", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxInt64) || val < float64(math.MinInt64) {
@@ -126,7 +131,7 @@ func RegisterFuzzyDecoders() {
 			*((*int64)(ptr)) = iter.ReadInt64()
 		}
 	}})
-	jsoniter.RegisterTypeDecoder("uint64", &FuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	jsoniter.RegisterTypeDecoder("uint64", &fuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 		if isFloat {
 			val := iter.ReadFloat64()
 			if val > float64(math.MaxUint64) || val < 0 {
@@ -144,7 +149,7 @@ type tolerateEmptyArrayExtension struct {
 	jsoniter.DummyExtension
 }
 
-func (extension *tolerateEmptyArrayExtension) DecorateDecoder(typ reflect.Type, decoder jsoniter.ValDecoder) jsoniter.ValDecoder {
+func (extension *tolerateEmptyArrayExtension) DecorateDecoder(typ reflect2.Type, decoder jsoniter.ValDecoder) jsoniter.ValDecoder {
 	if typ.Kind() == reflect.Struct || typ.Kind() == reflect.Map {
 		return &tolerateEmptyArrayDecoder{decoder}
 	}
@@ -156,99 +161,119 @@ type tolerateEmptyArrayDecoder struct {
 }
 
 func (decoder *tolerateEmptyArrayDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
-	if iter.WhatIsNext() == jsoniter.Array {
+	if iter.WhatIsNext() == jsoniter.ArrayValue {
 		iter.Skip()
-		newIter := iter.Config().BorrowIterator([]byte("{}"))
-		defer iter.Config().ReturnIterator(newIter)
+		newIter := iter.Pool().BorrowIterator([]byte("{}"))
+		defer iter.Pool().ReturnIterator(newIter)
 		decoder.valDecoder.Decode(ptr, newIter)
 	} else {
 		decoder.valDecoder.Decode(ptr, iter)
 	}
 }
 
-type FuzzyStringDecoder struct {
+type fuzzyStringDecoder struct {
 }
 
-func (decoder *FuzzyStringDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+func (decoder *fuzzyStringDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 	valueType := iter.WhatIsNext()
 	switch valueType {
-	case jsoniter.Number:
+	case jsoniter.NumberValue:
 		var number json.Number
 		iter.ReadVal(&number)
 		*((*string)(ptr)) = string(number)
-	case jsoniter.String:
+	case jsoniter.StringValue:
 		*((*string)(ptr)) = iter.ReadString()
 	default:
-		iter.ReportError("FuzzyStringDecoder", "not number or string")
+		iter.ReportError("fuzzyStringDecoder", "not number or string")
 	}
 }
 
-type FuzzyIntegerDecoder struct {
+type fuzzyIntegerDecoder struct {
 	fun func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator)
 }
 
-func (decoder *FuzzyIntegerDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+func (decoder *fuzzyIntegerDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 	valueType := iter.WhatIsNext()
 	var str string
 	switch valueType {
-	case jsoniter.Number:
+	case jsoniter.NumberValue:
 		var number json.Number
 		iter.ReadVal(&number)
 		str = string(number)
-	case jsoniter.String:
+	case jsoniter.StringValue:
 		str = iter.ReadString()
+	case jsoniter.BoolValue:
+		if iter.ReadBool() {
+			str = "1"
+		} else {
+			str = "0"
+		}
 	default:
-		iter.ReportError("FuzzyIntegerDecoder", "not number or string")
+		iter.ReportError("fuzzyIntegerDecoder", "not number or string")
 	}
-	newIter := iter.Config().BorrowIterator([]byte(str))
-	defer iter.Config().ReturnIterator(newIter)
+	newIter := iter.Pool().BorrowIterator([]byte(str))
+	defer iter.Pool().ReturnIterator(newIter)
 	isFloat := strings.IndexByte(str, '.') != -1
 	decoder.fun(isFloat, ptr, newIter)
-	if newIter.Error != nil {
+	if newIter.Error != nil && newIter.Error != io.EOF {
 		iter.Error = newIter.Error
 	}
 }
 
-type FuzzyFloat32Decoder struct {
+type fuzzyFloat32Decoder struct {
 }
 
-func (decoder *FuzzyFloat32Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+func (decoder *fuzzyFloat32Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 	valueType := iter.WhatIsNext()
 	var str string
 	switch valueType {
-	case jsoniter.Number:
+	case jsoniter.NumberValue:
 		*((*float32)(ptr)) = iter.ReadFloat32()
-	case jsoniter.String:
+	case jsoniter.StringValue:
 		str = iter.ReadString()
-		newIter := iter.Config().BorrowIterator([]byte(str))
-		defer iter.Config().ReturnIterator(newIter)
+		newIter := iter.Pool().BorrowIterator([]byte(str))
+		defer iter.Pool().ReturnIterator(newIter)
 		*((*float32)(ptr)) = newIter.ReadFloat32()
-		if newIter.Error != nil {
+		if newIter.Error != nil && newIter.Error != io.EOF {
 			iter.Error = newIter.Error
 		}
+	case jsoniter.BoolValue:
+		// support bool to float32
+		if iter.ReadBool() {
+			*((*float32)(ptr)) = 1
+		} else {
+			*((*float32)(ptr)) = 0
+		}
 	default:
-		iter.ReportError("FuzzyFloat32Decoder", "not number or string")
+		iter.ReportError("fuzzyFloat32Decoder", "not number or string")
 	}
 }
 
-type FuzzyFloat64Decoder struct {
+type fuzzyFloat64Decoder struct {
 }
 
-func (decoder *FuzzyFloat64Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+func (decoder *fuzzyFloat64Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 	valueType := iter.WhatIsNext()
 	var str string
 	switch valueType {
-	case jsoniter.Number:
+	case jsoniter.NumberValue:
 		*((*float64)(ptr)) = iter.ReadFloat64()
-	case jsoniter.String:
+	case jsoniter.StringValue:
 		str = iter.ReadString()
-		newIter := iter.Config().BorrowIterator([]byte(str))
-		defer iter.Config().ReturnIterator(newIter)
+		newIter := iter.Pool().BorrowIterator([]byte(str))
+		defer iter.Pool().ReturnIterator(newIter)
 		*((*float64)(ptr)) = newIter.ReadFloat64()
-		if newIter.Error != nil {
+		if newIter.Error != nil && newIter.Error != io.EOF {
 			iter.Error = newIter.Error
 		}
+	case jsoniter.BoolValue:
+		// support bool to float64
+		if iter.ReadBool() {
+			*((*float64)(ptr)) = 1
+		} else {
+			*((*float64)(ptr)) = 0
+		}
 	default:
-		iter.ReportError("FuzzyFloat32Decoder", "not number or string")
+		iter.ReportError("fuzzyFloat32Decoder", "not number or string")
 	}
 }

extra/fuzzy_decoder_test.go

@@ -1,89 +1,326 @@
 package extra
 
 import (
-	"github.com/json-iterator/go"
-	"github.com/json-iterator/go/require"
 	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
 )
 
 func init() {
 	RegisterFuzzyDecoders()
 }
 
-func Test_string_to_string(t *testing.T) {
+func Test_any_to_string(t *testing.T) {
 	should := require.New(t)
 	var val string
 	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
 	should.Equal("100", val)
+	should.Nil(jsoniter.UnmarshalFromString("10", &val))
+	should.Equal("10", val)
+	should.Nil(jsoniter.UnmarshalFromString("10.1", &val))
+	should.Equal("10.1", val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal("10.1", val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
 }
-
-func Test_int_to_string(t *testing.T) {
+func Test_any_to_int64(t *testing.T) {
 	should := require.New(t)
-	var val string
-	should.Nil(jsoniter.UnmarshalFromString(`100`, &val))
-	should.Equal("100", val)
-}
+	var val int64
 
-func Test_float_to_string(t *testing.T) {
-	should := require.New(t)
-	var val string
-	should.Nil(jsoniter.UnmarshalFromString(`12.0`, &val))
-	should.Equal("12.0", val)
-}
-
-func Test_string_to_int(t *testing.T) {
-	should := require.New(t)
-	var val int
 	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
-	should.Equal(100, val)
-}
+	should.Equal(int64(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int64(10), val)
 
-func Test_int_to_int(t *testing.T) {
-	should := require.New(t)
-	var val int
-	should.Nil(jsoniter.UnmarshalFromString(`100`, &val))
-	should.Equal(100, val)
-}
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int64(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int64(1), val)
 
-func Test_float_to_int(t *testing.T) {
-	should := require.New(t)
-	var val int
-	should.Nil(jsoniter.UnmarshalFromString(`1.23`, &val))
-	should.Equal(1, val)
-}
-
-func Test_large_float_to_int(t *testing.T) {
-	should := require.New(t)
-	var val int
+	should.Nil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(int64(-10), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
 	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
 }
 
-func Test_string_to_float32(t *testing.T) {
+func Test_any_to_int(t *testing.T) {
+	should := require.New(t)
+	var val int
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(100, val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(10, val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(10, val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(10, val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(0, val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(1, val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_int16(t *testing.T) {
+	should := require.New(t)
+	var val int16
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(int16(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int16(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int16(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int16(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_int32(t *testing.T) {
+	should := require.New(t)
+	var val int32
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(int32(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int32(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int32(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int32(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_int8(t *testing.T) {
+	should := require.New(t)
+	var val int8
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(int8(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(int8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(int8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(int8(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(int8(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(int8(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_uint8(t *testing.T) {
+	should := require.New(t)
+	var val uint8
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint8(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint8(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint8(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint8(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint8(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_uint64(t *testing.T) {
+	should := require.New(t)
+	var val uint64
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint64(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint64(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint64(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint64(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint64(1), val)
+
+	// TODO fix?
+	should.NotNil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(uint64(0), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+func Test_any_to_uint32(t *testing.T) {
+	should := require.New(t)
+	var val uint32
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint32(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint32(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint32(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint32(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint32(1), val)
+
+	// TODO fix?
+	should.NotNil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(uint32(0), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+func Test_any_to_uint16(t *testing.T) {
+	should := require.New(t)
+	var val uint16
+
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint16(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint16(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint16(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint16(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint16(1), val)
+
+	// TODO fix?
+	should.NotNil(jsoniter.UnmarshalFromString(`-10`, &val))
+	should.Equal(uint16(0), val)
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+func Test_any_to_uint(t *testing.T) {
+	should := require.New(t)
+	var val uint
+	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
+	should.Equal(uint(100), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(uint(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(uint(10), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(uint(10), val)
+
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(uint(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(uint(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
+	// large float to int
+	should.NotNil(jsoniter.UnmarshalFromString(`1234512345123451234512345.0`, &val))
+}
+
+func Test_any_to_float32(t *testing.T) {
 	should := require.New(t)
 	var val float32
 	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
 	should.Equal(float32(100), val)
+
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(float32(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(float32(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(float32(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(float32(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(float32(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
 }
 
-func Test_float_to_float32(t *testing.T) {
-	should := require.New(t)
-	var val float32
-	should.Nil(jsoniter.UnmarshalFromString(`1.23`, &val))
-	should.Equal(float32(1.23), val)
-}
-
-func Test_string_to_float64(t *testing.T) {
+func Test_any_to_float64(t *testing.T) {
 	should := require.New(t)
 	var val float64
+
 	should.Nil(jsoniter.UnmarshalFromString(`"100"`, &val))
 	should.Equal(float64(100), val)
-}
 
-func Test_float_to_float64(t *testing.T) {
-	should := require.New(t)
-	var val float64
-	should.Nil(jsoniter.UnmarshalFromString(`1.23`, &val))
-	should.Equal(float64(1.23), val)
+	should.Nil(jsoniter.UnmarshalFromString(`"10.1"`, &val))
+	should.Equal(float64(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10.1`, &val))
+	should.Equal(float64(10.1), val)
+	should.Nil(jsoniter.UnmarshalFromString(`10`, &val))
+	should.Equal(float64(10), val)
+
+	// bool part
+	should.Nil(jsoniter.UnmarshalFromString(`false`, &val))
+	should.Equal(float64(0), val)
+	should.Nil(jsoniter.UnmarshalFromString(`true`, &val))
+	should.Equal(float64(1), val)
+
+	should.NotNil(jsoniter.UnmarshalFromString("{}", &val))
+	should.NotNil(jsoniter.UnmarshalFromString("[]", &val))
 }
 
 func Test_empty_array_as_map(t *testing.T) {
@@ -99,3 +336,24 @@ func Test_empty_array_as_object(t *testing.T) {
 	should.Nil(jsoniter.UnmarshalFromString(`[]`, &val))
 	should.Equal(struct{}{}, val)
 }
+
+func Test_bad_case(t *testing.T) {
+	var jsonstr = `
+{
+    "extra_type": 181760,
+    "combo_type": 0,
+    "trigger_time_ms": 1498800398000,
+    "_create_time": "2017-06-16 11:21:39",
+    "_msg_type": 41000
+}
+`
+
+	type OrderEventRequestParams struct {
+		ExtraType uint64 `json:"extra_type"`
+	}
+
+	var a OrderEventRequestParams
+	err := jsoniter.UnmarshalFromString(jsonstr, &a)
+	should := require.New(t)
+	should.Nil(err)
+}

extra/naming_strategy.go

@@ -5,6 +5,7 @@ import (
 	"unicode"
 )
 
+// SetNamingStrategy rename struct fields uniformly
 func SetNamingStrategy(translate func(string) string) {
 	jsoniter.RegisterExtension(&namingStrategyExtension{jsoniter.DummyExtension{}, translate})
 }
@@ -16,11 +17,12 @@ type namingStrategyExtension struct {
 
 func (extension *namingStrategyExtension) UpdateStructDescriptor(structDescriptor *jsoniter.StructDescriptor) {
 	for _, binding := range structDescriptor.Fields {
-		binding.ToNames = []string{extension.translate(binding.Field.Name)}
-		binding.FromNames = []string{extension.translate(binding.Field.Name)}
+		binding.ToNames = []string{extension.translate(binding.Field.Name())}
+		binding.FromNames = []string{extension.translate(binding.Field.Name())}
 	}
 }
 
+// LowerCaseWithUnderscores one strategy to SetNamingStrategy for. It will change HelloWorld to hello_world.
 func LowerCaseWithUnderscores(name string) string {
 	newName := []rune{}
 	for i, c := range name {

extra/naming_strategy_test.go

@@ -2,7 +2,7 @@ package extra
 
 import (
 	"github.com/json-iterator/go"
-	"github.com/json-iterator/go/require"
+	"github.com/stretchr/testify/require"
 	"testing"
 )
 

extra/privat_fields.go

@@ -5,6 +5,7 @@ import (
 	"unicode"
 )
 
+// SupportPrivateFields include private fields when encoding/decoding
 func SupportPrivateFields() {
 	jsoniter.RegisterExtension(&privateFieldsExtension{})
 }
@@ -15,10 +16,10 @@ type privateFieldsExtension struct {
 
 func (extension *privateFieldsExtension) UpdateStructDescriptor(structDescriptor *jsoniter.StructDescriptor) {
 	for _, binding := range structDescriptor.Fields {
-		isPrivate := unicode.IsLower(rune(binding.Field.Name[0]))
+		isPrivate := unicode.IsLower(rune(binding.Field.Name()[0]))
 		if isPrivate {
-			binding.FromNames = []string{binding.Field.Name}
-			binding.ToNames = []string{binding.Field.Name}
+			binding.FromNames = []string{binding.Field.Name()}
+			binding.ToNames = []string{binding.Field.Name()}
 		}
 	}
 }

extra/private_fields_test.go

@@ -2,7 +2,7 @@ package extra
 
 import (
 	"github.com/json-iterator/go"
-	"github.com/json-iterator/go/require"
+	"github.com/stretchr/testify/require"
 	"testing"
 )
 

extra/time_as_int64_codec.go

@@ -6,7 +6,7 @@ import (
 	"unsafe"
 )
 
-// keep epoch milliseconds
+// RegisterTimeAsInt64Codec encode/decode time since number of unit since epoch. the precision is the unit.
 func RegisterTimeAsInt64Codec(precision time.Duration) {
 	jsoniter.RegisterTypeEncoder("time.Time", &timeAsInt64Codec{precision})
 	jsoniter.RegisterTypeDecoder("time.Time", &timeAsInt64Codec{precision})
@@ -29,6 +29,3 @@ func (codec *timeAsInt64Codec) Encode(ptr unsafe.Pointer, stream *jsoniter.Strea
 	ts := *((*time.Time)(ptr))
 	stream.WriteInt64(ts.UnixNano() / codec.precision.Nanoseconds())
 }
-func (codec *timeAsInt64Codec) EncodeInterface(val interface{}, stream *jsoniter.Stream) {
-	jsoniter.WriteToStream(val, stream, codec)
-}

extra/time_as_int64_codec_test.go

@@ -2,7 +2,7 @@ package extra
 
 import (
 	"github.com/json-iterator/go"
-	"github.com/json-iterator/go/require"
+	"github.com/stretchr/testify/require"
 	"testing"
 	"time"
 )
@@ -19,6 +19,7 @@ func Test_time_as_int64(t *testing.T) {
 }
 
 func Test_time_as_int64_keep_microsecond(t *testing.T) {
+	t.Skip("conflict")
 	should := require.New(t)
 	RegisterTimeAsInt64Codec(time.Microsecond)
 	output, err := jsoniter.Marshal(time.Unix(1, 1002))

feature_any_string.go

@@ -1,101 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"strconv"
-)
-
-type stringAny struct {
-	baseAny
-	val string
-}
-
-func (any *stringAny) Get(path ...interface{}) Any {
-	if len(path) == 0 {
-		return any
-	}
-	return &invalidAny{baseAny{}, fmt.Errorf("Get %v from simple value", path)}
-}
-
-func (any *stringAny) Parse() *Iterator {
-	return nil
-}
-
-func (any *stringAny) ValueType() ValueType {
-	return String
-}
-
-func (any *stringAny) MustBeValid() Any {
-	return any
-}
-
-func (any *stringAny) LastError() error {
-	return nil
-}
-
-func (any *stringAny) ToBool() bool {
-	str := any.ToString()
-	if str == "false" {
-		return false
-	}
-	for _, c := range str {
-		switch c {
-		case ' ', '\n', '\r', '\t':
-		default:
-			return true
-		}
-	}
-	return false
-}
-
-func (any *stringAny) ToInt() int {
-	parsed, _ := strconv.ParseInt(any.val, 10, 64)
-	return int(parsed)
-}
-
-func (any *stringAny) ToInt32() int32 {
-	parsed, _ := strconv.ParseInt(any.val, 10, 32)
-	return int32(parsed)
-}
-
-func (any *stringAny) ToInt64() int64 {
-	parsed, _ := strconv.ParseInt(any.val, 10, 64)
-	return parsed
-}
-
-func (any *stringAny) ToUint() uint {
-	parsed, _ := strconv.ParseUint(any.val, 10, 64)
-	return uint(parsed)
-}
-
-func (any *stringAny) ToUint32() uint32 {
-	parsed, _ := strconv.ParseUint(any.val, 10, 32)
-	return uint32(parsed)
-}
-
-func (any *stringAny) ToUint64() uint64 {
-	parsed, _ := strconv.ParseUint(any.val, 10, 64)
-	return parsed
-}
-
-func (any *stringAny) ToFloat32() float32 {
-	parsed, _ := strconv.ParseFloat(any.val, 32)
-	return float32(parsed)
-}
-
-func (any *stringAny) ToFloat64() float64 {
-	parsed, _ := strconv.ParseFloat(any.val, 64)
-	return parsed
-}
-
-func (any *stringAny) ToString() string {
-	return any.val
-}
-
-func (any *stringAny) WriteTo(stream *Stream) {
-	stream.WriteString(any.val)
-}
-
-func (any *stringAny) GetInterface() interface{} {
-	return any.val
-}

feature_config.go

@@ -1,282 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"errors"
-	"io"
-	"reflect"
-	"sync/atomic"
-	"unsafe"
-)
-
-type Config struct {
-	IndentionStep           int
-	MarshalFloatWith6Digits bool
-	EscapeHtml              bool
-	SortMapKeys             bool
-	UseNumber               bool
-}
-
-type frozenConfig struct {
-	configBeforeFrozen Config
-	sortMapKeys        bool
-	indentionStep      int
-	decoderCache       unsafe.Pointer
-	encoderCache       unsafe.Pointer
-	extensions         []Extension
-	streamPool         chan *Stream
-	iteratorPool       chan *Iterator
-}
-
-type Api interface {
-	MarshalToString(v interface{}) (string, error)
-	Marshal(v interface{}) ([]byte, error)
-	UnmarshalFromString(str string, v interface{}) error
-	Unmarshal(data []byte, v interface{}) error
-	Get(data []byte, path ...interface{}) Any
-	NewEncoder(writer io.Writer) *Encoder
-	NewDecoder(reader io.Reader) *Decoder
-}
-
-var ConfigDefault = Config{
-	EscapeHtml: true,
-}.Froze()
-
-// Trying to be 100% compatible with standard library behavior
-var ConfigCompatibleWithStandardLibrary = Config{
-	EscapeHtml:  true,
-	SortMapKeys: true,
-}.Froze()
-
-var ConfigFastest = Config{
-	EscapeHtml:  false,
-	MarshalFloatWith6Digits: true,
-}.Froze()
-
-func (cfg Config) Froze() *frozenConfig {
-	frozenConfig := &frozenConfig{
-		sortMapKeys:   cfg.SortMapKeys,
-		indentionStep: cfg.IndentionStep,
-		streamPool:    make(chan *Stream, 16),
-		iteratorPool:  make(chan *Iterator, 16),
-	}
-	atomic.StorePointer(&frozenConfig.decoderCache, unsafe.Pointer(&map[string]ValDecoder{}))
-	atomic.StorePointer(&frozenConfig.encoderCache, unsafe.Pointer(&map[string]ValEncoder{}))
-	if cfg.MarshalFloatWith6Digits {
-		frozenConfig.marshalFloatWith6Digits()
-	}
-	if cfg.EscapeHtml {
-		frozenConfig.escapeHtml()
-	}
-	if cfg.UseNumber {
-		frozenConfig.useNumber()
-	}
-	frozenConfig.configBeforeFrozen = cfg
-	return frozenConfig
-}
-
-func (cfg *frozenConfig) useNumber() {
-	cfg.addDecoderToCache(reflect.TypeOf((*interface{})(nil)).Elem(), &funcDecoder{func(ptr unsafe.Pointer, iter *Iterator) {
-		if iter.WhatIsNext() == Number {
-			*((*interface{})(ptr)) = json.Number(iter.readNumberAsString())
-		} else {
-			*((*interface{})(ptr)) = iter.Read()
-		}
-	}})
-}
-
-func (cfg *frozenConfig) registerExtension(extension Extension) {
-	cfg.extensions = append(cfg.extensions, extension)
-}
-
-type lossyFloat32Encoder struct {
-}
-
-func (encoder *lossyFloat32Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteFloat32Lossy(*((*float32)(ptr)))
-}
-
-func (encoder *lossyFloat32Encoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *lossyFloat32Encoder) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*float32)(ptr)) == 0
-}
-
-type lossyFloat64Encoder struct {
-}
-
-func (encoder *lossyFloat64Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteFloat64Lossy(*((*float64)(ptr)))
-}
-
-func (encoder *lossyFloat64Encoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *lossyFloat64Encoder) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*float64)(ptr)) == 0
-}
-
-// EnableLossyFloatMarshalling keeps 10**(-6) precision
-// for float variables for better performance.
-func (cfg *frozenConfig) marshalFloatWith6Digits() {
-	// for better performance
-	cfg.addEncoderToCache(reflect.TypeOf((*float32)(nil)).Elem(), &lossyFloat32Encoder{})
-	cfg.addEncoderToCache(reflect.TypeOf((*float64)(nil)).Elem(), &lossyFloat64Encoder{})
-}
-
-type htmlEscapedStringEncoder struct {
-}
-
-func (encoder *htmlEscapedStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	str := *((*string)(ptr))
-	stream.WriteStringWithHtmlEscaped(str)
-}
-
-func (encoder *htmlEscapedStringEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *htmlEscapedStringEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*string)(ptr)) == ""
-}
-
-func (cfg *frozenConfig) escapeHtml() {
-	// for better performance
-	cfg.addEncoderToCache(reflect.TypeOf((*string)(nil)).Elem(), &htmlEscapedStringEncoder{})
-}
-
-func (cfg *frozenConfig) addDecoderToCache(cacheKey reflect.Type, decoder ValDecoder) {
-	done := false
-	for !done {
-		ptr := atomic.LoadPointer(&cfg.decoderCache)
-		cache := *(*map[reflect.Type]ValDecoder)(ptr)
-		copied := map[reflect.Type]ValDecoder{}
-		for k, v := range cache {
-			copied[k] = v
-		}
-		copied[cacheKey] = decoder
-		done = atomic.CompareAndSwapPointer(&cfg.decoderCache, ptr, unsafe.Pointer(&copied))
-	}
-}
-
-func (cfg *frozenConfig) addEncoderToCache(cacheKey reflect.Type, encoder ValEncoder) {
-	done := false
-	for !done {
-		ptr := atomic.LoadPointer(&cfg.encoderCache)
-		cache := *(*map[reflect.Type]ValEncoder)(ptr)
-		copied := map[reflect.Type]ValEncoder{}
-		for k, v := range cache {
-			copied[k] = v
-		}
-		copied[cacheKey] = encoder
-		done = atomic.CompareAndSwapPointer(&cfg.encoderCache, ptr, unsafe.Pointer(&copied))
-	}
-}
-
-func (cfg *frozenConfig) getDecoderFromCache(cacheKey reflect.Type) ValDecoder {
-	ptr := atomic.LoadPointer(&cfg.decoderCache)
-	cache := *(*map[reflect.Type]ValDecoder)(ptr)
-	return cache[cacheKey]
-}
-
-func (cfg *frozenConfig) getEncoderFromCache(cacheKey reflect.Type) ValEncoder {
-	ptr := atomic.LoadPointer(&cfg.encoderCache)
-	cache := *(*map[reflect.Type]ValEncoder)(ptr)
-	return cache[cacheKey]
-}
-
-// cleanDecoders cleans decoders registered or cached
-func (cfg *frozenConfig) cleanDecoders() {
-	typeDecoders = map[string]ValDecoder{}
-	fieldDecoders = map[string]ValDecoder{}
-	atomic.StorePointer(&cfg.decoderCache, unsafe.Pointer(&map[string]ValDecoder{}))
-}
-
-// cleanEncoders cleans encoders registered or cached
-func (cfg *frozenConfig) cleanEncoders() {
-	typeEncoders = map[string]ValEncoder{}
-	fieldEncoders = map[string]ValEncoder{}
-	atomic.StorePointer(&cfg.encoderCache, unsafe.Pointer(&map[string]ValEncoder{}))
-}
-
-func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) {
-	stream := cfg.BorrowStream(nil)
-	defer cfg.ReturnStream(stream)
-	stream.WriteVal(v)
-	if stream.Error != nil {
-		return "", stream.Error
-	}
-	return string(stream.Buffer()), nil
-}
-
-func (cfg *frozenConfig) Marshal(v interface{}) ([]byte, error) {
-	stream := cfg.BorrowStream(nil)
-	defer cfg.ReturnStream(stream)
-	stream.WriteVal(v)
-	if stream.Error != nil {
-		return nil, stream.Error
-	}
-	result := stream.Buffer()
-	copied := make([]byte, len(result))
-	copy(copied, result)
-	return copied, nil
-}
-
-func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {
-	data := []byte(str)
-	data = data[:lastNotSpacePos(data)]
-	iter := cfg.BorrowIterator(data)
-	defer cfg.ReturnIterator(iter)
-	iter.ReadVal(v)
-	if iter.head == iter.tail {
-		iter.loadMore()
-	}
-	if iter.Error == io.EOF {
-		return nil
-	}
-	if iter.Error == nil {
-		iter.ReportError("UnmarshalFromString", "there are bytes left after unmarshal")
-	}
-	return iter.Error
-}
-
-func (cfg *frozenConfig) Get(data []byte, path ...interface{}) Any {
-	iter := cfg.BorrowIterator(data)
-	defer cfg.ReturnIterator(iter)
-	return locatePath(iter, path)
-}
-
-func (cfg *frozenConfig) Unmarshal(data []byte, v interface{}) error {
-	data = data[:lastNotSpacePos(data)]
-	iter := cfg.BorrowIterator(data)
-	defer cfg.ReturnIterator(iter)
-	typ := reflect.TypeOf(v)
-	if typ.Kind() != reflect.Ptr {
-		// return non-pointer error
-		return errors.New("the second param must be ptr type")
-	}
-	iter.ReadVal(v)
-	if iter.head == iter.tail {
-		iter.loadMore()
-	}
-	if iter.Error == io.EOF {
-		return nil
-	}
-	if iter.Error == nil {
-		iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
-	}
-	return iter.Error
-}
-
-func (cfg *frozenConfig) NewEncoder(writer io.Writer) *Encoder {
-	stream := NewStream(cfg, writer, 512)
-	return &Encoder{stream}
-}
-
-func (cfg *frozenConfig) NewDecoder(reader io.Reader) *Decoder {
-	iter := Parse(cfg, reader, 512)
-	return &Decoder{iter}
-}

feature_iter_object.go

@@ -1,195 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"unicode"
-	"unsafe"
-)
-
-func (iter *Iterator) ReadObject() (ret string) {
-	c := iter.nextToken()
-	switch c {
-	case 'n':
-		iter.skipFixedBytes(3)
-		return "" // null
-	case '{':
-		c = iter.nextToken()
-		if c == '"' {
-			iter.unreadByte()
-			return string(iter.readObjectFieldAsBytes())
-		}
-		if c == '}' {
-			return "" // end of object
-		}
-		iter.ReportError("ReadObject", `expect " after {`)
-		return
-	case ',':
-		return string(iter.readObjectFieldAsBytes())
-	case '}':
-		return "" // end of object
-	default:
-		iter.ReportError("ReadObject", fmt.Sprintf(`expect { or , or } or n, but found %s`, string([]byte{c})))
-		return
-	}
-}
-
-func (iter *Iterator) readFieldHash() int32 {
-	hash := int64(0x811c9dc5)
-	c := iter.nextToken()
-	if c == '"' {
-		for {
-			for i := iter.head; i < iter.tail; i++ {
-				// require ascii string and no escape
-				b := iter.buf[i]
-				if 'A' <= b && b <= 'Z' {
-					b += 'a' - 'A'
-				}
-				if b == '"' {
-					iter.head = i + 1
-					c = iter.nextToken()
-					if c != ':' {
-						iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
-					}
-					return int32(hash)
-				}
-				hash ^= int64(b)
-				hash *= 0x1000193
-			}
-			if !iter.loadMore() {
-				iter.ReportError("readFieldHash", `incomplete field name`)
-				return 0
-			}
-		}
-	}
-	iter.ReportError("readFieldHash", `expect ", but found `+string([]byte{c}))
-	return 0
-}
-
-func calcHash(str string) int32 {
-	hash := int64(0x811c9dc5)
-	for _, b := range str {
-		hash ^= int64(unicode.ToLower(b))
-		hash *= 0x1000193
-	}
-	return int32(hash)
-}
-
-func (iter *Iterator) ReadObjectCB(callback func(*Iterator, string) bool) bool {
-	c := iter.nextToken()
-	if c == '{' {
-		c = iter.nextToken()
-		if c == '"' {
-			iter.unreadByte()
-			field := iter.readObjectFieldAsBytes()
-			if !callback(iter, *(*string)(unsafe.Pointer(&field))) {
-				return false
-			}
-			for iter.nextToken() == ',' {
-				field = iter.readObjectFieldAsBytes()
-				if !callback(iter, *(*string)(unsafe.Pointer(&field))) {
-					return false
-				}
-			}
-			return true
-		}
-		if c == '}' {
-			return true
-		}
-		iter.ReportError("ReadObjectCB", `expect " after }`)
-		return false
-	}
-	if c == 'n' {
-		iter.skipFixedBytes(3)
-		return true // null
-	}
-	iter.ReportError("ReadObjectCB", `expect { or n`)
-	return false
-}
-
-func (iter *Iterator) ReadMapCB(callback func(*Iterator, string) bool) bool {
-	c := iter.nextToken()
-	if c == '{' {
-		c = iter.nextToken()
-		if c == '"' {
-			iter.unreadByte()
-			field := iter.ReadString()
-			if iter.nextToken() != ':' {
-				iter.ReportError("ReadMapCB", "expect : after object field")
-				return false
-			}
-			if !callback(iter, field) {
-				return false
-			}
-			for iter.nextToken() == ',' {
-				field = iter.ReadString()
-				if iter.nextToken() != ':' {
-					iter.ReportError("ReadMapCB", "expect : after object field")
-					return false
-				}
-				if !callback(iter, field) {
-					return false
-				}
-			}
-			return true
-		}
-		if c == '}' {
-			return true
-		}
-		iter.ReportError("ReadMapCB", `expect " after }`)
-		return false
-	}
-	if c == 'n' {
-		iter.skipFixedBytes(3)
-		return true // null
-	}
-	iter.ReportError("ReadMapCB", `expect { or n`)
-	return false
-}
-
-func (iter *Iterator) readObjectStart() bool {
-	c := iter.nextToken()
-	if c == '{' {
-		c = iter.nextToken()
-		if c == '}' {
-			return false
-		}
-		iter.unreadByte()
-		return true
-	} else if c == 'n' {
-		iter.skipFixedBytes(3)
-		return false
-	}
-	iter.ReportError("readObjectStart", "expect { or n")
-	return false
-}
-
-func (iter *Iterator) readObjectFieldAsBytes() (ret []byte) {
-	str := iter.ReadStringAsSlice()
-	if iter.skipWhitespacesWithoutLoadMore() {
-		if ret == nil {
-			ret = make([]byte, len(str))
-			copy(ret, str)
-		}
-		if !iter.loadMore() {
-			return
-		}
-	}
-	if iter.buf[iter.head] != ':' {
-		iter.ReportError("readObjectFieldAsBytes", "expect : after object field")
-		return
-	}
-	iter.head++
-	if iter.skipWhitespacesWithoutLoadMore() {
-		if ret == nil {
-			ret = make([]byte, len(str))
-			copy(ret, str)
-		}
-		if !iter.loadMore() {
-			return
-		}
-	}
-	if ret == nil {
-		return str
-	}
-	return ret
-}

feature_pool.go

@@ -1,45 +0,0 @@
-package jsoniter
-
-import (
-	"io"
-)
-
-func (cfg *frozenConfig) BorrowStream(writer io.Writer) *Stream {
-	select {
-	case stream := <-cfg.streamPool:
-		stream.Reset(writer)
-		return stream
-	default:
-		return NewStream(cfg, writer, 512)
-	}
-}
-
-func (cfg *frozenConfig) ReturnStream(stream *Stream) {
-	stream.Error = nil
-	select {
-	case cfg.streamPool <- stream:
-		return
-	default:
-		return
-	}
-}
-
-func (cfg *frozenConfig) BorrowIterator(data []byte) *Iterator {
-	select {
-	case iter := <-cfg.iteratorPool:
-		iter.ResetBytes(data)
-		return iter
-	default:
-		return ParseBytes(cfg, data)
-	}
-}
-
-func (cfg *frozenConfig) ReturnIterator(iter *Iterator) {
-	iter.Error = nil
-	select {
-	case cfg.iteratorPool <- iter:
-		return
-	default:
-		return
-	}
-}

feature_reflect.go

@@ -1,465 +0,0 @@
-package jsoniter
-
-import (
-	"encoding"
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"time"
-	"unsafe"
-)
-
-// ValDecoder is an internal type registered to cache as needed.
-// Don't confuse jsoniter.ValDecoder with json.Decoder.
-// For json.Decoder's adapter, refer to jsoniter.AdapterDecoder(todo link).
-//
-// Reflection on type to create decoders, which is then cached
-// Reflection on value is avoided as we can, as the reflect.Value itself will allocate, with following exceptions
-// 1. create instance of new value, for example *int will need a int to be allocated
-// 2. append to slice, if the existing cap is not enough, allocate will be done using Reflect.New
-// 3. assignment to map, both key and value will be reflect.Value
-// For a simple struct binding, it will be reflect.Value free and allocation free
-type ValDecoder interface {
-	Decode(ptr unsafe.Pointer, iter *Iterator)
-}
-
-// ValEncoder is an internal type registered to cache as needed.
-// Don't confuse jsoniter.ValEncoder with json.Encoder.
-// For json.Encoder's adapter, refer to jsoniter.AdapterEncoder(todo godoc link).
-type ValEncoder interface {
-	IsEmpty(ptr unsafe.Pointer) bool
-	Encode(ptr unsafe.Pointer, stream *Stream)
-	EncodeInterface(val interface{}, stream *Stream)
-}
-
-func WriteToStream(val interface{}, stream *Stream, encoder ValEncoder) {
-	e := (*emptyInterface)(unsafe.Pointer(&val))
-	if e.word == nil {
-		stream.WriteNil()
-		return
-	}
-	if reflect.TypeOf(val).Kind() == reflect.Ptr {
-		encoder.Encode(unsafe.Pointer(&e.word), stream)
-	} else {
-		encoder.Encode(e.word, stream)
-	}
-}
-
-type DecoderFunc func(ptr unsafe.Pointer, iter *Iterator)
-type EncoderFunc func(ptr unsafe.Pointer, stream *Stream)
-
-var jsonNumberType reflect.Type
-var jsonRawMessageType reflect.Type
-var jsoniterRawMessageType reflect.Type
-var anyType reflect.Type
-var marshalerType reflect.Type
-var unmarshalerType reflect.Type
-var textUnmarshalerType reflect.Type
-
-func init() {
-	jsonNumberType = reflect.TypeOf((*json.Number)(nil)).Elem()
-	jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
-	jsoniterRawMessageType = reflect.TypeOf((*RawMessage)(nil)).Elem()
-	anyType = reflect.TypeOf((*Any)(nil)).Elem()
-	marshalerType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
-	unmarshalerType = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
-	textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
-}
-
-type optionalDecoder struct {
-	valueType    reflect.Type
-	valueDecoder ValDecoder
-}
-
-func (decoder *optionalDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*unsafe.Pointer)(ptr)) = nil
-	} else {
-		if *((*unsafe.Pointer)(ptr)) == nil {
-			// pointer to null, we have to allocate memory to hold the value
-			value := reflect.New(decoder.valueType)
-			decoder.valueDecoder.Decode(unsafe.Pointer(value.Pointer()), iter)
-			*((*uintptr)(ptr)) = value.Pointer()
-		} else {
-			// reuse existing instance
-			decoder.valueDecoder.Decode(*((*unsafe.Pointer)(ptr)), iter)
-		}
-	}
-}
-
-type optionalEncoder struct {
-	valueEncoder ValEncoder
-}
-
-func (encoder *optionalEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	if *((*unsafe.Pointer)(ptr)) == nil {
-		stream.WriteNil()
-	} else {
-		encoder.valueEncoder.Encode(*((*unsafe.Pointer)(ptr)), stream)
-	}
-}
-
-func (encoder *optionalEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *optionalEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	if *((*unsafe.Pointer)(ptr)) == nil {
-		return true
-	} else {
-		return encoder.valueEncoder.IsEmpty(*((*unsafe.Pointer)(ptr)))
-	}
-}
-
-type placeholderEncoder struct {
-	cfg      *frozenConfig
-	cacheKey reflect.Type
-}
-
-func (encoder *placeholderEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	encoder.getRealEncoder().Encode(ptr, stream)
-}
-
-func (encoder *placeholderEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *placeholderEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	return encoder.getRealEncoder().IsEmpty(ptr)
-}
-
-func (encoder *placeholderEncoder) getRealEncoder() ValEncoder {
-	for i := 0; i < 30; i++ {
-		realDecoder := encoder.cfg.getEncoderFromCache(encoder.cacheKey)
-		_, isPlaceholder := realDecoder.(*placeholderEncoder)
-		if isPlaceholder {
-			time.Sleep(time.Second)
-		} else {
-			return realDecoder
-		}
-	}
-	panic(fmt.Sprintf("real encoder not found for cache key: %v", encoder.cacheKey))
-}
-
-type placeholderDecoder struct {
-	cfg      *frozenConfig
-	cacheKey reflect.Type
-}
-
-func (decoder *placeholderDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	for i := 0; i < 30; i++ {
-		realDecoder := decoder.cfg.getDecoderFromCache(decoder.cacheKey)
-		_, isPlaceholder := realDecoder.(*placeholderDecoder)
-		if isPlaceholder {
-			time.Sleep(time.Second)
-		} else {
-			realDecoder.Decode(ptr, iter)
-			return
-		}
-	}
-	panic(fmt.Sprintf("real decoder not found for cache key: %v", decoder.cacheKey))
-}
-
-// emptyInterface is the header for an interface{} value.
-type emptyInterface struct {
-	typ  unsafe.Pointer
-	word unsafe.Pointer
-}
-
-// emptyInterface is the header for an interface with method (not interface{})
-type nonEmptyInterface struct {
-	// see ../runtime/iface.go:/Itab
-	itab *struct {
-		ityp   unsafe.Pointer // static interface type
-		typ    unsafe.Pointer // dynamic concrete type
-		link   unsafe.Pointer
-		bad    int32
-		unused int32
-		fun    [100000]unsafe.Pointer // method table
-	}
-	word unsafe.Pointer
-}
-
-// Read converts an Iterator instance into go interface, same as json.Unmarshal
-func (iter *Iterator) ReadVal(obj interface{}) {
-	typ := reflect.TypeOf(obj)
-	cacheKey := typ.Elem()
-	decoder, err := decoderOfType(iter.cfg, cacheKey)
-	if err != nil {
-		iter.Error = err
-		return
-	}
-	e := (*emptyInterface)(unsafe.Pointer(&obj))
-	decoder.Decode(e.word, iter)
-}
-
-func (stream *Stream) WriteVal(val interface{}) {
-	if nil == val {
-		stream.WriteNil()
-		return
-	}
-	typ := reflect.TypeOf(val)
-	cacheKey := typ
-	encoder, err := encoderOfType(stream.cfg, cacheKey)
-	if err != nil {
-		stream.Error = err
-		return
-	}
-	encoder.EncodeInterface(val, stream)
-}
-
-type prefix string
-
-func (p prefix) addToDecoder(decoder ValDecoder, err error) (ValDecoder, error) {
-	if err != nil {
-		return nil, fmt.Errorf("%s: %s", p, err.Error())
-	}
-	return decoder, err
-}
-
-func (p prefix) addToEncoder(encoder ValEncoder, err error) (ValEncoder, error) {
-	if err != nil {
-		return nil, fmt.Errorf("%s: %s", p, err.Error())
-	}
-	return encoder, err
-}
-
-func decoderOfType(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
-	cacheKey := typ
-	decoder := cfg.getDecoderFromCache(cacheKey)
-	if decoder != nil {
-		return decoder, nil
-	}
-	decoder = getTypeDecoderFromExtension(typ)
-	if decoder != nil {
-		cfg.addDecoderToCache(cacheKey, decoder)
-		return decoder, nil
-	}
-	decoder = &placeholderDecoder{cfg: cfg, cacheKey: cacheKey}
-	cfg.addDecoderToCache(cacheKey, decoder)
-	decoder, err := createDecoderOfType(cfg, typ)
-	for _, extension := range extensions {
-		decoder = extension.DecorateDecoder(typ, decoder)
-	}
-	cfg.addDecoderToCache(cacheKey, decoder)
-	return decoder, err
-}
-
-func createDecoderOfType(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
-	if typ.String() == "[]uint8" {
-		return &base64Codec{}, nil
-	}
-	if typ.AssignableTo(jsonRawMessageType) {
-		return &jsonRawMessageCodec{}, nil
-	}
-	if typ.AssignableTo(jsoniterRawMessageType) {
-		return &jsoniterRawMessageCodec{}, nil
-	}
-	if typ.AssignableTo(jsonNumberType) {
-		return &jsonNumberCodec{}, nil
-	}
-	if typ.ConvertibleTo(unmarshalerType) {
-		templateInterface := reflect.New(typ).Elem().Interface()
-		var decoder ValDecoder = &unmarshalerDecoder{extractInterface(templateInterface)}
-		if typ.Kind() != reflect.Struct {
-			decoder = &optionalDecoder{typ, decoder}
-		}
-		return decoder, nil
-	}
-	if typ.ConvertibleTo(anyType) {
-		return &anyCodec{}, nil
-	}
-	switch typ.Kind() {
-	case reflect.String:
-		return &stringCodec{}, nil
-	case reflect.Int:
-		return &intCodec{}, nil
-	case reflect.Int8:
-		return &int8Codec{}, nil
-	case reflect.Int16:
-		return &int16Codec{}, nil
-	case reflect.Int32:
-		return &int32Codec{}, nil
-	case reflect.Int64:
-		return &int64Codec{}, nil
-	case reflect.Uint:
-		return &uintCodec{}, nil
-	case reflect.Uint8:
-		return &uint8Codec{}, nil
-	case reflect.Uint16:
-		return &uint16Codec{}, nil
-	case reflect.Uint32:
-		return &uint32Codec{}, nil
-	case reflect.Uint64:
-		return &uint64Codec{}, nil
-	case reflect.Float32:
-		return &float32Codec{}, nil
-	case reflect.Float64:
-		return &float64Codec{}, nil
-	case reflect.Bool:
-		return &boolCodec{}, nil
-	case reflect.Interface:
-		if typ.NumMethod() == 0 {
-			return &emptyInterfaceCodec{}, nil
-		} else {
-			return &nonEmptyInterfaceCodec{}, nil
-		}
-	case reflect.Struct:
-		return prefix(fmt.Sprintf("[%s]", typ.String())).addToDecoder(decoderOfStruct(cfg, typ))
-	case reflect.Array:
-		return prefix("[array]").addToDecoder(decoderOfArray(cfg, typ))
-	case reflect.Slice:
-		return prefix("[slice]").addToDecoder(decoderOfSlice(cfg, typ))
-	case reflect.Map:
-		return prefix("[map]").addToDecoder(decoderOfMap(cfg, typ))
-	case reflect.Ptr:
-		return prefix("[optional]").addToDecoder(decoderOfOptional(cfg, typ))
-	default:
-		return nil, fmt.Errorf("unsupported type: %v", typ)
-	}
-}
-
-func encoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
-	cacheKey := typ
-	encoder := cfg.getEncoderFromCache(cacheKey)
-	if encoder != nil {
-		return encoder, nil
-	}
-	encoder = getTypeEncoderFromExtension(typ)
-	if encoder != nil {
-		cfg.addEncoderToCache(cacheKey, encoder)
-		return encoder, nil
-	}
-	encoder = &placeholderEncoder{cfg: cfg, cacheKey: cacheKey}
-	cfg.addEncoderToCache(cacheKey, encoder)
-	encoder, err := createEncoderOfType(cfg, typ)
-	for _, extension := range extensions {
-		encoder = extension.DecorateEncoder(typ, encoder)
-	}
-	cfg.addEncoderToCache(cacheKey, encoder)
-	return encoder, err
-}
-
-func createEncoderOfType(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
-	if typ.String() == "[]uint8" {
-		return &base64Codec{}, nil
-	}
-	if typ.AssignableTo(jsonRawMessageType) {
-		return &jsonRawMessageCodec{}, nil
-	}
-	if typ.AssignableTo(jsoniterRawMessageType) {
-		return &jsoniterRawMessageCodec{}, nil
-	}
-	if typ.AssignableTo(jsonNumberType) {
-		return &jsonNumberCodec{}, nil
-	}
-	if typ.ConvertibleTo(marshalerType) {
-		templateInterface := reflect.New(typ).Elem().Interface()
-		var encoder ValEncoder = &marshalerEncoder{extractInterface(templateInterface)}
-		if typ.Kind() != reflect.Struct {
-			encoder = &optionalEncoder{encoder}
-		}
-		return encoder, nil
-	}
-	if typ.ConvertibleTo(anyType) {
-		return &anyCodec{}, nil
-	}
-	kind := typ.Kind()
-	switch kind {
-	case reflect.String:
-		return &stringCodec{}, nil
-	case reflect.Int:
-		return &intCodec{}, nil
-	case reflect.Int8:
-		return &int8Codec{}, nil
-	case reflect.Int16:
-		return &int16Codec{}, nil
-	case reflect.Int32:
-		return &int32Codec{}, nil
-	case reflect.Int64:
-		return &int64Codec{}, nil
-	case reflect.Uint:
-		return &uintCodec{}, nil
-	case reflect.Uint8:
-		return &uint8Codec{}, nil
-	case reflect.Uint16:
-		return &uint16Codec{}, nil
-	case reflect.Uint32:
-		return &uint32Codec{}, nil
-	case reflect.Uint64:
-		return &uint64Codec{}, nil
-	case reflect.Float32:
-		return &float32Codec{}, nil
-	case reflect.Float64:
-		return &float64Codec{}, nil
-	case reflect.Bool:
-		return &boolCodec{}, nil
-	case reflect.Interface:
-		if typ.NumMethod() == 0 {
-			return &emptyInterfaceCodec{}, nil
-		} else {
-			return &nonEmptyInterfaceCodec{}, nil
-		}
-	case reflect.Struct:
-		return prefix(fmt.Sprintf("[%s]", typ.String())).addToEncoder(encoderOfStruct(cfg, typ))
-	case reflect.Array:
-		return prefix("[array]").addToEncoder(encoderOfArray(cfg, typ))
-	case reflect.Slice:
-		return prefix("[slice]").addToEncoder(encoderOfSlice(cfg, typ))
-	case reflect.Map:
-		return prefix("[map]").addToEncoder(encoderOfMap(cfg, typ))
-	case reflect.Ptr:
-		return prefix("[optional]").addToEncoder(encoderOfOptional(cfg, typ))
-	default:
-		return nil, fmt.Errorf("unsupported type: %v", typ)
-	}
-}
-
-func decoderOfOptional(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
-	elemType := typ.Elem()
-	decoder, err := decoderOfType(cfg, elemType)
-	if err != nil {
-		return nil, err
-	}
-	return &optionalDecoder{elemType, decoder}, nil
-}
-
-func encoderOfOptional(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
-	elemType := typ.Elem()
-	elemEncoder, err := encoderOfType(cfg, elemType)
-	if err != nil {
-		return nil, err
-	}
-	encoder := &optionalEncoder{elemEncoder}
-	if elemType.Kind() == reflect.Map {
-		encoder = &optionalEncoder{encoder}
-	}
-	return encoder, nil
-}
-
-func decoderOfMap(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
-	decoder, err := decoderOfType(cfg, typ.Elem())
-	if err != nil {
-		return nil, err
-	}
-	mapInterface := reflect.New(typ).Interface()
-	return &mapDecoder{typ, typ.Key(), typ.Elem(), decoder, extractInterface(mapInterface)}, nil
-}
-
-func extractInterface(val interface{}) emptyInterface {
-	return *((*emptyInterface)(unsafe.Pointer(&val)))
-}
-
-func encoderOfMap(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
-	elemType := typ.Elem()
-	encoder, err := encoderOfType(cfg, elemType)
-	if err != nil {
-		return nil, err
-	}
-	mapInterface := reflect.New(typ).Elem().Interface()
-	if cfg.sortMapKeys {
-		return &sortKeysMapEncoder{typ, elemType, encoder, *((*emptyInterface)(unsafe.Pointer(&mapInterface)))}, nil
-	} else {
-		return &mapEncoder{typ, elemType, encoder, *((*emptyInterface)(unsafe.Pointer(&mapInterface)))}, nil
-	}
-}

feature_reflect_array.go

@@ -1,84 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"io"
-	"reflect"
-	"unsafe"
-)
-
-func decoderOfArray(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
-	decoder, err := decoderOfType(cfg, typ.Elem())
-	if err != nil {
-		return nil, err
-	}
-	return &arrayDecoder{typ, typ.Elem(), decoder}, nil
-}
-
-func encoderOfArray(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
-	encoder, err := encoderOfType(cfg, typ.Elem())
-	if err != nil {
-		return nil, err
-	}
-	if typ.Elem().Kind() == reflect.Map {
-		encoder = &optionalEncoder{encoder}
-	}
-	return &arrayEncoder{typ, typ.Elem(), encoder}, nil
-}
-
-type arrayEncoder struct {
-	arrayType   reflect.Type
-	elemType    reflect.Type
-	elemEncoder ValEncoder
-}
-
-func (encoder *arrayEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	if ptr == nil {
-		stream.WriteNil()
-		return
-	}
-	stream.WriteArrayStart()
-	elemPtr := uintptr(ptr)
-	encoder.elemEncoder.Encode(unsafe.Pointer(elemPtr), stream)
-	for i := 1; i < encoder.arrayType.Len(); i++ {
-		stream.WriteMore()
-		elemPtr += encoder.elemType.Size()
-		encoder.elemEncoder.Encode(unsafe.Pointer(elemPtr), stream)
-	}
-	stream.WriteArrayEnd()
-	if stream.Error != nil && stream.Error != io.EOF {
-		stream.Error = fmt.Errorf("%v: %s", encoder.arrayType, stream.Error.Error())
-	}
-}
-
-func (encoder *arrayEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *arrayEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	return false
-}
-
-type arrayDecoder struct {
-	arrayType   reflect.Type
-	elemType    reflect.Type
-	elemDecoder ValDecoder
-}
-
-func (decoder *arrayDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	decoder.doDecode(ptr, iter)
-	if iter.Error != nil && iter.Error != io.EOF {
-		iter.Error = fmt.Errorf("%v: %s", decoder.arrayType, iter.Error.Error())
-	}
-}
-
-func (decoder *arrayDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
-	offset := uintptr(0)
-	for ; iter.ReadArray(); offset += decoder.elemType.Size() {
-		if offset < decoder.arrayType.Size() {
-			decoder.elemDecoder.Decode(unsafe.Pointer(uintptr(ptr)+offset), iter)
-		} else {
-			iter.Skip()
-		}
-	}
-}

feature_reflect_extension.go

@@ -1,299 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"unicode"
-	"unsafe"
-)
-
-var typeDecoders = map[string]ValDecoder{}
-var fieldDecoders = map[string]ValDecoder{}
-var typeEncoders = map[string]ValEncoder{}
-var fieldEncoders = map[string]ValEncoder{}
-var extensions = []Extension{}
-
-type StructDescriptor struct {
-	Type   reflect.Type
-	Fields []*Binding
-}
-
-func (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding {
-	for _, binding := range structDescriptor.Fields {
-		if binding.Field.Name == fieldName {
-			return binding
-		}
-	}
-	return nil
-}
-
-type Binding struct {
-	Field     *reflect.StructField
-	FromNames []string
-	ToNames   []string
-	Encoder   ValEncoder
-	Decoder   ValDecoder
-}
-
-type Extension interface {
-	UpdateStructDescriptor(structDescriptor *StructDescriptor)
-	CreateDecoder(typ reflect.Type) ValDecoder
-	CreateEncoder(typ reflect.Type) ValEncoder
-	DecorateDecoder(typ reflect.Type, decoder ValDecoder) ValDecoder
-	DecorateEncoder(typ reflect.Type, encoder ValEncoder) ValEncoder
-}
-
-type DummyExtension struct {
-}
-
-func (extension *DummyExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
-}
-
-func (extension *DummyExtension) CreateDecoder(typ reflect.Type) ValDecoder {
-	return nil
-}
-
-func (extension *DummyExtension) CreateEncoder(typ reflect.Type) ValEncoder {
-	return nil
-}
-
-func (extension *DummyExtension) DecorateDecoder(typ reflect.Type, decoder ValDecoder) ValDecoder {
-	return decoder
-}
-
-func (extension *DummyExtension) DecorateEncoder(typ reflect.Type, encoder ValEncoder) ValEncoder {
-	return encoder
-}
-
-type funcDecoder struct {
-	fun DecoderFunc
-}
-
-func (decoder *funcDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	decoder.fun(ptr, iter)
-}
-
-type funcEncoder struct {
-	fun         EncoderFunc
-	isEmptyFunc func(ptr unsafe.Pointer) bool
-}
-
-func (encoder *funcEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	encoder.fun(ptr, stream)
-}
-
-func (encoder *funcEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	if encoder.isEmptyFunc == nil {
-		return false
-	}
-	return encoder.isEmptyFunc(ptr)
-}
-
-func RegisterTypeDecoderFunc(typ string, fun DecoderFunc) {
-	typeDecoders[typ] = &funcDecoder{fun}
-}
-
-func RegisterTypeDecoder(typ string, decoder ValDecoder) {
-	typeDecoders[typ] = decoder
-}
-
-func RegisterFieldDecoderFunc(typ string, field string, fun DecoderFunc) {
-	RegisterFieldDecoder(typ, field, &funcDecoder{fun})
-}
-
-func RegisterFieldDecoder(typ string, field string, decoder ValDecoder) {
-	fieldDecoders[fmt.Sprintf("%s/%s", typ, field)] = decoder
-}
-
-func RegisterTypeEncoderFunc(typ string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
-	typeEncoders[typ] = &funcEncoder{fun, isEmptyFunc}
-}
-
-func RegisterTypeEncoder(typ string, encoder ValEncoder) {
-	typeEncoders[typ] = encoder
-}
-
-func RegisterFieldEncoderFunc(typ string, field string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
-	RegisterFieldEncoder(typ, field, &funcEncoder{fun, isEmptyFunc})
-}
-
-func RegisterFieldEncoder(typ string, field string, encoder ValEncoder) {
-	fieldEncoders[fmt.Sprintf("%s/%s", typ, field)] = encoder
-}
-
-func RegisterExtension(extension Extension) {
-	extensions = append(extensions, extension)
-}
-
-func getTypeDecoderFromExtension(typ reflect.Type) ValDecoder {
-	decoder := _getTypeDecoderFromExtension(typ)
-	if decoder != nil {
-		for _, extension := range extensions {
-			decoder = extension.DecorateDecoder(typ, decoder)
-		}
-	}
-	return decoder
-}
-func _getTypeDecoderFromExtension(typ reflect.Type) ValDecoder {
-	for _, extension := range extensions {
-		decoder := extension.CreateDecoder(typ)
-		if decoder != nil {
-			return decoder
-		}
-	}
-	typeName := typ.String()
-	decoder := typeDecoders[typeName]
-	if decoder != nil {
-		return decoder
-	}
-	if typ.Kind() == reflect.Ptr {
-		decoder := typeDecoders[typ.Elem().String()]
-		if decoder != nil {
-			return &optionalDecoder{typ.Elem(), decoder}
-		}
-	}
-	return nil
-}
-
-func getTypeEncoderFromExtension(typ reflect.Type) ValEncoder {
-	encoder := _getTypeEncoderFromExtension(typ)
-	if encoder != nil {
-		for _, extension := range extensions {
-			encoder = extension.DecorateEncoder(typ, encoder)
-		}
-	}
-	return encoder
-}
-
-func _getTypeEncoderFromExtension(typ reflect.Type) ValEncoder {
-	for _, extension := range extensions {
-		encoder := extension.CreateEncoder(typ)
-		if encoder != nil {
-			return encoder
-		}
-	}
-	typeName := typ.String()
-	encoder := typeEncoders[typeName]
-	if encoder != nil {
-		return encoder
-	}
-	if typ.Kind() == reflect.Ptr {
-		encoder := typeEncoders[typ.Elem().String()]
-		if encoder != nil {
-			return &optionalEncoder{encoder}
-		}
-	}
-	return nil
-}
-
-func describeStruct(cfg *frozenConfig, typ reflect.Type) (*StructDescriptor, error) {
-	anonymousBindings := []*Binding{}
-	bindings := []*Binding{}
-	for i := 0; i < typ.NumField(); i++ {
-		field := typ.Field(i)
-		if field.Anonymous {
-			if field.Type.Kind() == reflect.Struct {
-				structDescriptor, err := describeStruct(cfg, field.Type)
-				if err != nil {
-					return nil, err
-				}
-				for _, binding := range structDescriptor.Fields {
-					anonymousBindings = append(anonymousBindings, binding)
-				}
-			} else if field.Type.Kind() == reflect.Ptr && field.Type.Elem().Kind() == reflect.Struct {
-				structDescriptor, err := describeStruct(cfg, field.Type.Elem())
-				if err != nil {
-					return nil, err
-				}
-				for _, binding := range structDescriptor.Fields {
-					binding.Encoder = &optionalEncoder{binding.Encoder}
-					binding.Encoder = &structFieldEncoder{&field, binding.Encoder, false}
-					binding.Decoder = &optionalDecoder{field.Type, binding.Decoder}
-					binding.Decoder = &structFieldDecoder{&field, binding.Decoder}
-					anonymousBindings = append(anonymousBindings, binding)
-				}
-			}
-		} else {
-			tagParts := strings.Split(field.Tag.Get("json"), ",")
-			fieldNames := calcFieldNames(field.Name, tagParts[0])
-			fieldCacheKey := fmt.Sprintf("%s/%s", typ.String(), field.Name)
-			decoder := fieldDecoders[fieldCacheKey]
-			if decoder == nil {
-				var err error
-				decoder, err = decoderOfType(cfg, field.Type)
-				if err != nil {
-					return nil, err
-				}
-			}
-			encoder := fieldEncoders[fieldCacheKey]
-			if encoder == nil {
-				var err error
-				encoder, err = encoderOfType(cfg, field.Type)
-				if err != nil {
-					return nil, err
-				}
-				// map is stored as pointer in the struct
-				if field.Type.Kind() == reflect.Map {
-					encoder = &optionalEncoder{encoder}
-				}
-			}
-			binding := &Binding{
-				Field:     &field,
-				FromNames: fieldNames,
-				ToNames:   fieldNames,
-				Decoder:   decoder,
-				Encoder:   encoder,
-			}
-			bindings = append(bindings, binding)
-		}
-	}
-	structDescriptor := &StructDescriptor{
-		Type:   typ,
-		Fields: bindings,
-	}
-	for _, extension := range extensions {
-		extension.UpdateStructDescriptor(structDescriptor)
-	}
-	for _, binding := range structDescriptor.Fields {
-		shouldOmitEmpty := false
-		tagParts := strings.Split(binding.Field.Tag.Get("json"), ",")
-		for _, tagPart := range tagParts[1:] {
-			if tagPart == "omitempty" {
-				shouldOmitEmpty = true
-			} else if tagPart == "string" {
-				binding.Decoder = &stringModeDecoder{binding.Decoder}
-				binding.Encoder = &stringModeEncoder{binding.Encoder}
-			}
-		}
-		binding.Decoder = &structFieldDecoder{binding.Field, binding.Decoder}
-		binding.Encoder = &structFieldEncoder{binding.Field, binding.Encoder, shouldOmitEmpty}
-	}
-	// insert anonymous bindings to the head
-	structDescriptor.Fields = append(anonymousBindings, structDescriptor.Fields...)
-	return structDescriptor, nil
-}
-
-func calcFieldNames(originalFieldName string, tagProvidedFieldName string) []string {
-	// tag => exported? => original
-	isNotExported := unicode.IsLower(rune(originalFieldName[0]))
-	var fieldNames []string
-	/// tagParts[0] always present, even if no tags
-	switch tagProvidedFieldName {
-	case "":
-		if isNotExported {
-			fieldNames = []string{}
-		} else {
-			fieldNames = []string{originalFieldName}
-		}
-	case "-":
-		fieldNames = []string{}
-	default:
-		fieldNames = []string{tagProvidedFieldName}
-	}
-	return fieldNames
-}

feature_reflect_map.go

@@ -1,190 +0,0 @@
-package jsoniter
-
-import (
-	"encoding"
-	"encoding/json"
-	"reflect"
-	"sort"
-	"strconv"
-	"unsafe"
-)
-
-type mapDecoder struct {
-	mapType      reflect.Type
-	keyType      reflect.Type
-	elemType     reflect.Type
-	elemDecoder  ValDecoder
-	mapInterface emptyInterface
-}
-
-func (decoder *mapDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	// dark magic to cast unsafe.Pointer back to interface{} using reflect.Type
-	mapInterface := decoder.mapInterface
-	mapInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
-	realVal := reflect.ValueOf(*realInterface).Elem()
-	if realVal.IsNil() {
-		realVal.Set(reflect.MakeMap(realVal.Type()))
-	}
-	iter.ReadMapCB(func(iter *Iterator, keyStr string) bool {
-		elem := reflect.New(decoder.elemType)
-		decoder.elemDecoder.Decode(unsafe.Pointer(elem.Pointer()), iter)
-		// to put into map, we have to use reflection
-		keyType := decoder.keyType
-		switch {
-		case keyType.Kind() == reflect.String:
-			realVal.SetMapIndex(reflect.ValueOf(keyStr), elem.Elem())
-			return true
-		case keyType.Implements(textUnmarshalerType):
-			textUnmarshaler := reflect.New(keyType.Elem()).Interface().(encoding.TextUnmarshaler)
-			err := textUnmarshaler.UnmarshalText([]byte(keyStr))
-			if err != nil {
-				iter.ReportError("read map key as TextUnmarshaler", err.Error())
-				return false
-			}
-			realVal.SetMapIndex(reflect.ValueOf(textUnmarshaler), elem.Elem())
-			return true
-		default:
-			switch keyType.Kind() {
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				n, err := strconv.ParseInt(keyStr, 10, 64)
-				if err != nil || reflect.Zero(keyType).OverflowInt(n) {
-					iter.ReportError("read map key as int64", "read int64 failed")
-					return false
-				}
-				realVal.SetMapIndex(reflect.ValueOf(n).Convert(keyType), elem.Elem())
-				return true
-			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-				n, err := strconv.ParseUint(keyStr, 10, 64)
-				if err != nil || reflect.Zero(keyType).OverflowUint(n) {
-					iter.ReportError("read map key as uint64", "read uint64 failed")
-					return false
-				}
-				realVal.SetMapIndex(reflect.ValueOf(n).Convert(keyType), elem.Elem())
-				return true
-			}
-		}
-		iter.ReportError("read map key", "unexpected map key type "+keyType.String())
-		return true
-	})
-}
-
-type mapEncoder struct {
-	mapType      reflect.Type
-	elemType     reflect.Type
-	elemEncoder  ValEncoder
-	mapInterface emptyInterface
-}
-
-func (encoder *mapEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	mapInterface := encoder.mapInterface
-	mapInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
-	realVal := reflect.ValueOf(*realInterface)
-
-	stream.WriteObjectStart()
-	for i, key := range realVal.MapKeys() {
-		if i != 0 {
-			stream.WriteMore()
-		}
-		encodeMapKey(key, stream)
-		stream.writeByte(':')
-		val := realVal.MapIndex(key).Interface()
-		encoder.elemEncoder.EncodeInterface(val, stream)
-	}
-	stream.WriteObjectEnd()
-}
-
-func encodeMapKey(key reflect.Value, stream *Stream) {
-	if key.Kind() == reflect.String {
-		stream.WriteString(key.String())
-		return
-	}
-	if tm, ok := key.Interface().(encoding.TextMarshaler); ok {
-		buf, err := tm.MarshalText()
-		if err != nil {
-			stream.Error = err
-			return
-		}
-		stream.writeByte('"')
-		stream.Write(buf)
-		stream.writeByte('"')
-		return
-	}
-	switch key.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		stream.writeByte('"')
-		stream.WriteInt64(key.Int())
-		stream.writeByte('"')
-		return
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		stream.writeByte('"')
-		stream.WriteUint64(key.Uint())
-		stream.writeByte('"')
-		return
-	}
-	stream.Error = &json.UnsupportedTypeError{key.Type()}
-}
-
-func (encoder *mapEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *mapEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	mapInterface := encoder.mapInterface
-	mapInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
-	realVal := reflect.ValueOf(*realInterface)
-	return realVal.Len() == 0
-}
-
-type sortKeysMapEncoder struct {
-	mapType      reflect.Type
-	elemType     reflect.Type
-	elemEncoder  ValEncoder
-	mapInterface emptyInterface
-}
-
-func (encoder *sortKeysMapEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	mapInterface := encoder.mapInterface
-	mapInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
-	realVal := reflect.ValueOf(*realInterface)
-
-	// Extract and sort the keys.
-	var sv stringValues = realVal.MapKeys()
-	sort.Sort(sv)
-
-	stream.WriteObjectStart()
-	for i, key := range sv {
-		if i != 0 {
-			stream.WriteMore()
-		}
-		encodeMapKey(key, stream)
-		stream.writeByte(':')
-		val := realVal.MapIndex(key).Interface()
-		encoder.elemEncoder.EncodeInterface(val, stream)
-	}
-	stream.WriteObjectEnd()
-}
-
-// stringValues is a slice of reflect.Value holding *reflect.StringValue.
-// It implements the methods to sort by string.
-type stringValues []reflect.Value
-
-func (sv stringValues) Len() int           { return len(sv) }
-func (sv stringValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
-func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) }
-func (sv stringValues) get(i int) string   { return sv[i].String() }
-
-func (encoder *sortKeysMapEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *sortKeysMapEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	mapInterface := encoder.mapInterface
-	mapInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
-	realVal := reflect.ValueOf(*realInterface)
-	return realVal.Len() == 0
-}

feature_reflect_native.go

@@ -1,535 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"unsafe"
-)
-
-type stringCodec struct {
-}
-
-func (codec *stringCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*string)(ptr)) = iter.ReadString()
-}
-
-func (codec *stringCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	str := *((*string)(ptr))
-	stream.WriteString(str)
-}
-
-func (codec *stringCodec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, codec)
-}
-
-func (codec *stringCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*string)(ptr)) == ""
-}
-
-type intCodec struct {
-}
-
-func (codec *intCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*int)(ptr)) = iter.ReadInt()
-}
-
-func (codec *intCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteInt(*((*int)(ptr)))
-}
-
-func (encoder *intCodec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *intCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*int)(ptr)) == 0
-}
-
-type int8Codec struct {
-}
-
-func (codec *int8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*int8)(ptr)) = iter.ReadInt8()
-}
-
-func (codec *int8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteInt8(*((*int8)(ptr)))
-}
-
-func (encoder *int8Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *int8Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*int8)(ptr)) == 0
-}
-
-type int16Codec struct {
-}
-
-func (codec *int16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*int16)(ptr)) = iter.ReadInt16()
-}
-
-func (codec *int16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteInt16(*((*int16)(ptr)))
-}
-
-func (encoder *int16Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *int16Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*int16)(ptr)) == 0
-}
-
-type int32Codec struct {
-}
-
-func (codec *int32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*int32)(ptr)) = iter.ReadInt32()
-}
-
-func (codec *int32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteInt32(*((*int32)(ptr)))
-}
-
-func (encoder *int32Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *int32Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*int32)(ptr)) == 0
-}
-
-type int64Codec struct {
-}
-
-func (codec *int64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*int64)(ptr)) = iter.ReadInt64()
-}
-
-func (codec *int64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteInt64(*((*int64)(ptr)))
-}
-
-func (encoder *int64Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *int64Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*int64)(ptr)) == 0
-}
-
-type uintCodec struct {
-}
-
-func (codec *uintCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*uint)(ptr)) = iter.ReadUint()
-}
-
-func (codec *uintCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteUint(*((*uint)(ptr)))
-}
-
-func (encoder *uintCodec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *uintCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*uint)(ptr)) == 0
-}
-
-type uint8Codec struct {
-}
-
-func (codec *uint8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*uint8)(ptr)) = iter.ReadUint8()
-}
-
-func (codec *uint8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteUint8(*((*uint8)(ptr)))
-}
-
-func (encoder *uint8Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *uint8Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*uint8)(ptr)) == 0
-}
-
-type uint16Codec struct {
-}
-
-func (decoder *uint16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*uint16)(ptr)) = iter.ReadUint16()
-}
-
-func (codec *uint16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteUint16(*((*uint16)(ptr)))
-}
-
-func (encoder *uint16Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *uint16Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*uint16)(ptr)) == 0
-}
-
-type uint32Codec struct {
-}
-
-func (codec *uint32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*uint32)(ptr)) = iter.ReadUint32()
-}
-
-func (codec *uint32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteUint32(*((*uint32)(ptr)))
-}
-
-func (encoder *uint32Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *uint32Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*uint32)(ptr)) == 0
-}
-
-type uint64Codec struct {
-}
-
-func (codec *uint64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*uint64)(ptr)) = iter.ReadUint64()
-}
-
-func (codec *uint64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteUint64(*((*uint64)(ptr)))
-}
-
-func (encoder *uint64Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *uint64Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*uint64)(ptr)) == 0
-}
-
-type float32Codec struct {
-}
-
-func (codec *float32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*float32)(ptr)) = iter.ReadFloat32()
-}
-
-func (codec *float32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteFloat32(*((*float32)(ptr)))
-}
-
-func (encoder *float32Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *float32Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*float32)(ptr)) == 0
-}
-
-type float64Codec struct {
-}
-
-func (codec *float64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*float64)(ptr)) = iter.ReadFloat64()
-}
-
-func (codec *float64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteFloat64(*((*float64)(ptr)))
-}
-
-func (encoder *float64Codec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *float64Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return *((*float64)(ptr)) == 0
-}
-
-type boolCodec struct {
-}
-
-func (codec *boolCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*bool)(ptr)) = iter.ReadBool()
-}
-
-func (codec *boolCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteBool(*((*bool)(ptr)))
-}
-
-func (encoder *boolCodec) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (codec *boolCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return !(*((*bool)(ptr)))
-}
-
-type emptyInterfaceCodec struct {
-}
-
-func (codec *emptyInterfaceCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*interface{})(ptr)) = iter.Read()
-}
-
-func (codec *emptyInterfaceCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteVal(*((*interface{})(ptr)))
-}
-
-func (encoder *emptyInterfaceCodec) EncodeInterface(val interface{}, stream *Stream) {
-	stream.WriteVal(val)
-}
-
-func (codec *emptyInterfaceCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return ptr == nil
-}
-
-type nonEmptyInterfaceCodec struct {
-}
-
-func (codec *nonEmptyInterfaceCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	nonEmptyInterface := (*nonEmptyInterface)(ptr)
-	if nonEmptyInterface.itab == nil {
-		iter.ReportError("read non-empty interface", "do not know which concrete type to decode to")
-		return
-	}
-	var i interface{}
-	e := (*emptyInterface)(unsafe.Pointer(&i))
-	e.typ = nonEmptyInterface.itab.typ
-	e.word = nonEmptyInterface.word
-	iter.ReadVal(&i)
-	nonEmptyInterface.word = e.word
-}
-
-func (codec *nonEmptyInterfaceCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	nonEmptyInterface := (*nonEmptyInterface)(ptr)
-	var i interface{}
-	e := (*emptyInterface)(unsafe.Pointer(&i))
-	e.typ = nonEmptyInterface.itab.typ
-	e.word = nonEmptyInterface.word
-	stream.WriteVal(i)
-}
-
-func (encoder *nonEmptyInterfaceCodec) EncodeInterface(val interface{}, stream *Stream) {
-	stream.WriteVal(val)
-}
-
-func (codec *nonEmptyInterfaceCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	nonEmptyInterface := (*nonEmptyInterface)(ptr)
-	return nonEmptyInterface.word == nil
-}
-
-type anyCodec struct {
-}
-
-func (codec *anyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*Any)(ptr)) = iter.ReadAny()
-}
-
-func (codec *anyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	(*((*Any)(ptr))).WriteTo(stream)
-}
-
-func (encoder *anyCodec) EncodeInterface(val interface{}, stream *Stream) {
-	(val.(Any)).WriteTo(stream)
-}
-
-func (encoder *anyCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return (*((*Any)(ptr))).Size() == 0
-}
-
-type jsonNumberCodec struct {
-}
-
-func (codec *jsonNumberCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*json.Number)(ptr)) = json.Number([]byte(iter.readNumberAsString()))
-}
-
-func (codec *jsonNumberCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteRaw(string(*((*json.Number)(ptr))))
-}
-
-func (encoder *jsonNumberCodec) EncodeInterface(val interface{}, stream *Stream) {
-	stream.WriteRaw(string(val.(json.Number)))
-}
-
-func (encoder *jsonNumberCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return len(*((*json.Number)(ptr))) == 0
-}
-
-type jsonRawMessageCodec struct {
-}
-
-func (codec *jsonRawMessageCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*json.RawMessage)(ptr)) = json.RawMessage(iter.SkipAndReturnBytes())
-}
-
-func (codec *jsonRawMessageCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteRaw(string(*((*json.RawMessage)(ptr))))
-}
-
-func (encoder *jsonRawMessageCodec) EncodeInterface(val interface{}, stream *Stream) {
-	stream.WriteRaw(string(val.(json.RawMessage)))
-}
-
-func (encoder *jsonRawMessageCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return len(*((*json.RawMessage)(ptr))) == 0
-}
-
-type jsoniterRawMessageCodec struct {
-}
-
-func (codec *jsoniterRawMessageCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	*((*RawMessage)(ptr)) = RawMessage(iter.SkipAndReturnBytes())
-}
-
-func (codec *jsoniterRawMessageCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.WriteRaw(string(*((*RawMessage)(ptr))))
-}
-
-func (encoder *jsoniterRawMessageCodec) EncodeInterface(val interface{}, stream *Stream) {
-	stream.WriteRaw(string(val.(RawMessage)))
-}
-
-func (encoder *jsoniterRawMessageCodec) IsEmpty(ptr unsafe.Pointer) bool {
-	return len(*((*RawMessage)(ptr))) == 0
-}
-
-type base64Codec struct {
-}
-
-func (codec *base64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	encoding := base64.StdEncoding
-	src := iter.SkipAndReturnBytes()
-	src = src[1 : len(src)-1]
-	decodedLen := encoding.DecodedLen(len(src))
-	dst := make([]byte, decodedLen)
-	_, err := encoding.Decode(dst, src)
-	if err != nil {
-		iter.ReportError("decode base64", err.Error())
-	} else {
-		*((*[]byte)(ptr)) = dst
-	}
-}
-
-func (codec *base64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
-	encoding := base64.StdEncoding
-	stream.writeByte('"')
-	src := *((*[]byte)(ptr))
-	toGrow := encoding.EncodedLen(len(src))
-	stream.ensure(toGrow)
-	encoding.Encode(stream.buf[stream.n:], src)
-	stream.n += toGrow
-	stream.writeByte('"')
-}
-
-func (encoder *base64Codec) EncodeInterface(val interface{}, stream *Stream) {
-	encoding := base64.StdEncoding
-	stream.writeByte('"')
-	src := val.([]byte)
-	toGrow := encoding.EncodedLen(len(src))
-	stream.ensure(toGrow)
-	encoding.Encode(stream.buf[stream.n:], src)
-	stream.n += toGrow
-	stream.writeByte('"')
-}
-
-func (encoder *base64Codec) IsEmpty(ptr unsafe.Pointer) bool {
-	return len(*((*[]byte)(ptr))) == 0
-}
-
-type stringModeDecoder struct {
-	elemDecoder ValDecoder
-}
-
-func (decoder *stringModeDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	c := iter.nextToken()
-	if c != '"' {
-		iter.ReportError("stringModeDecoder", `expect "`)
-		return
-	}
-	decoder.elemDecoder.Decode(ptr, iter)
-	if iter.Error != nil {
-		return
-	}
-	c = iter.readByte()
-	if c != '"' {
-		iter.ReportError("stringModeDecoder", `expect "`)
-		return
-	}
-}
-
-type stringModeEncoder struct {
-	elemEncoder ValEncoder
-}
-
-func (encoder *stringModeEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	stream.writeByte('"')
-	encoder.elemEncoder.Encode(ptr, stream)
-	stream.writeByte('"')
-}
-
-func (encoder *stringModeEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *stringModeEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	return encoder.elemEncoder.IsEmpty(ptr)
-}
-
-type marshalerEncoder struct {
-	templateInterface emptyInterface
-}
-
-func (encoder *marshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	templateInterface := encoder.templateInterface
-	templateInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&templateInterface))
-	marshaler := (*realInterface).(json.Marshaler)
-	bytes, err := marshaler.MarshalJSON()
-	if err != nil {
-		stream.Error = err
-	} else {
-		stream.Write(bytes)
-	}
-}
-func (encoder *marshalerEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *marshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	templateInterface := encoder.templateInterface
-	templateInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&templateInterface))
-	marshaler := (*realInterface).(json.Marshaler)
-	bytes, err := marshaler.MarshalJSON()
-	if err != nil {
-		return true
-	} else {
-		return len(bytes) > 0
-	}
-}
-
-type unmarshalerDecoder struct {
-	templateInterface emptyInterface
-}
-
-func (decoder *unmarshalerDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	templateInterface := decoder.templateInterface
-	templateInterface.word = ptr
-	realInterface := (*interface{})(unsafe.Pointer(&templateInterface))
-	unmarshaler := (*realInterface).(json.Unmarshaler)
-	bytes := iter.SkipAndReturnBytes()
-	err := unmarshaler.UnmarshalJSON(bytes)
-	if err != nil {
-		iter.ReportError("unmarshaler", err.Error())
-	}
-}

feature_reflect_slice.go

@@ -1,162 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"io"
-	"reflect"
-	"unsafe"
-)
-
-func decoderOfSlice(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
-	decoder, err := decoderOfType(cfg, typ.Elem())
-	if err != nil {
-		return nil, err
-	}
-	return &sliceDecoder{typ, typ.Elem(), decoder}, nil
-}
-
-func encoderOfSlice(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
-	encoder, err := encoderOfType(cfg, typ.Elem())
-	if err != nil {
-		return nil, err
-	}
-	if typ.Elem().Kind() == reflect.Map {
-		encoder = &optionalEncoder{encoder}
-	}
-	return &sliceEncoder{typ, typ.Elem(), encoder}, nil
-}
-
-type sliceEncoder struct {
-	sliceType   reflect.Type
-	elemType    reflect.Type
-	elemEncoder ValEncoder
-}
-
-func (encoder *sliceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	slice := (*sliceHeader)(ptr)
-	if slice.Data == nil {
-		stream.WriteNil()
-		return
-	}
-	if slice.Len == 0 {
-		stream.WriteEmptyArray()
-		return
-	}
-	stream.WriteArrayStart()
-	elemPtr := uintptr(slice.Data)
-	encoder.elemEncoder.Encode(unsafe.Pointer(elemPtr), stream)
-	for i := 1; i < slice.Len; i++ {
-		stream.WriteMore()
-		elemPtr += encoder.elemType.Size()
-		encoder.elemEncoder.Encode(unsafe.Pointer(elemPtr), stream)
-	}
-	stream.WriteArrayEnd()
-	if stream.Error != nil && stream.Error != io.EOF {
-		stream.Error = fmt.Errorf("%v: %s", encoder.sliceType, stream.Error.Error())
-	}
-}
-
-func (encoder *sliceEncoder) EncodeInterface(val interface{}, stream *Stream) {
-	WriteToStream(val, stream, encoder)
-}
-
-func (encoder *sliceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
-	slice := (*sliceHeader)(ptr)
-	return slice.Len == 0
-}
-
-type sliceDecoder struct {
-	sliceType   reflect.Type
-	elemType    reflect.Type
-	elemDecoder ValDecoder
-}
-
-// sliceHeader is a safe version of SliceHeader used within this package.
-type sliceHeader struct {
-	Data unsafe.Pointer
-	Len  int
-	Cap  int
-}
-
-func (decoder *sliceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	decoder.doDecode(ptr, iter)
-	if iter.Error != nil && iter.Error != io.EOF {
-		iter.Error = fmt.Errorf("%v: %s", decoder.sliceType, iter.Error.Error())
-	}
-}
-
-func (decoder *sliceDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
-	slice := (*sliceHeader)(ptr)
-	reuseSlice(slice, decoder.sliceType, 4)
-	if !iter.ReadArray() {
-		return
-	}
-	offset := uintptr(0)
-	decoder.elemDecoder.Decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
-	if !iter.ReadArray() {
-		slice.Len = 1
-		return
-	}
-	offset += decoder.elemType.Size()
-	decoder.elemDecoder.Decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
-	if !iter.ReadArray() {
-		slice.Len = 2
-		return
-	}
-	offset += decoder.elemType.Size()
-	decoder.elemDecoder.Decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
-	if !iter.ReadArray() {
-		slice.Len = 3
-		return
-	}
-	offset += decoder.elemType.Size()
-	decoder.elemDecoder.Decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
-	slice.Len = 4
-	for iter.ReadArray() {
-		growOne(slice, decoder.sliceType, decoder.elemType)
-		offset += decoder.elemType.Size()
-		decoder.elemDecoder.Decode(unsafe.Pointer(uintptr(slice.Data)+offset), iter)
-	}
-}
-
-// grow grows the slice s so that it can hold extra more values, allocating
-// more capacity if needed. It also returns the old and new slice lengths.
-func growOne(slice *sliceHeader, sliceType reflect.Type, elementType reflect.Type) {
-	newLen := slice.Len + 1
-	if newLen <= slice.Cap {
-		slice.Len = newLen
-		return
-	}
-	newCap := slice.Cap
-	if newCap == 0 {
-		newCap = 1
-	} else {
-		for newCap < newLen {
-			if slice.Len < 1024 {
-				newCap += newCap
-			} else {
-				newCap += newCap / 4
-			}
-		}
-	}
-	dst := unsafe.Pointer(reflect.MakeSlice(sliceType, newLen, newCap).Pointer())
-	// copy old array into new array
-	originalBytesCount := uintptr(slice.Len) * elementType.Size()
-	srcPtr := (*[1 << 30]byte)(slice.Data)
-	dstPtr := (*[1 << 30]byte)(dst)
-	for i := uintptr(0); i < originalBytesCount; i++ {
-		dstPtr[i] = srcPtr[i]
-	}
-	slice.Len = newLen
-	slice.Cap = newCap
-	slice.Data = dst
-}
-
-func reuseSlice(slice *sliceHeader, sliceType reflect.Type, expectedCap int) {
-	if expectedCap <= slice.Cap {
-		return
-	}
-	dst := unsafe.Pointer(reflect.MakeSlice(sliceType, 0, expectedCap).Pointer())
-	slice.Cap = expectedCap
-	slice.Data = dst
-}

feature_stream.go

@@ -1,275 +0,0 @@
-package jsoniter
-
-import (
-	"io"
-)
-
-type Stream struct {
-	cfg       *frozenConfig
-	out       io.Writer
-	buf       []byte
-	n         int
-	Error     error
-	indention int
-}
-
-func NewStream(cfg *frozenConfig, out io.Writer, bufSize int) *Stream {
-	return &Stream{
-		cfg:       cfg,
-		out:       out,
-		buf:       make([]byte, bufSize),
-		n:         0,
-		Error:     nil,
-		indention: 0,
-	}
-}
-
-func (b *Stream) Reset(out io.Writer) {
-	b.out = out
-	b.n = 0
-}
-
-// Available returns how many bytes are unused in the buffer.
-func (b *Stream) Available() int {
-	return len(b.buf) - b.n
-}
-
-// Buffered returns the number of bytes that have been written into the current buffer.
-func (b *Stream) Buffered() int {
-	return b.n
-}
-
-func (b *Stream) Buffer() []byte {
-	return b.buf[:b.n]
-}
-
-// Write writes the contents of p into the buffer.
-// It returns the number of bytes written.
-// If nn < len(p), it also returns an error explaining
-// why the write is short.
-func (b *Stream) Write(p []byte) (nn int, err error) {
-	for len(p) > b.Available() && b.Error == nil {
-		if b.out == nil {
-			b.growAtLeast(len(p))
-		} else {
-			var n int
-			if b.Buffered() == 0 {
-				// Large write, empty buffer.
-				// Write directly from p to avoid copy.
-				n, b.Error = b.out.Write(p)
-			} else {
-				n = copy(b.buf[b.n:], p)
-				b.n += n
-				b.Flush()
-			}
-			nn += n
-			p = p[n:]
-		}
-	}
-	if b.Error != nil {
-		return nn, b.Error
-	}
-	n := copy(b.buf[b.n:], p)
-	b.n += n
-	nn += n
-	return nn, nil
-}
-
-// WriteByte writes a single byte.
-func (b *Stream) writeByte(c byte) {
-	if b.Error != nil {
-		return
-	}
-	if b.Available() < 1 {
-		b.growAtLeast(1)
-	}
-	b.buf[b.n] = c
-	b.n++
-}
-
-func (b *Stream) writeTwoBytes(c1 byte, c2 byte) {
-	if b.Error != nil {
-		return
-	}
-	if b.Available() < 2 {
-		b.growAtLeast(2)
-	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.n += 2
-}
-
-func (b *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
-	if b.Error != nil {
-		return
-	}
-	if b.Available() < 3 {
-		b.growAtLeast(3)
-	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.buf[b.n+2] = c3
-	b.n += 3
-}
-
-func (b *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
-	if b.Error != nil {
-		return
-	}
-	if b.Available() < 4 {
-		b.growAtLeast(4)
-	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.buf[b.n+2] = c3
-	b.buf[b.n+3] = c4
-	b.n += 4
-}
-
-func (b *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
-	if b.Error != nil {
-		return
-	}
-	if b.Available() < 5 {
-		b.growAtLeast(5)
-	}
-	b.buf[b.n] = c1
-	b.buf[b.n+1] = c2
-	b.buf[b.n+2] = c3
-	b.buf[b.n+3] = c4
-	b.buf[b.n+4] = c5
-	b.n += 5
-}
-
-// Flush writes any buffered data to the underlying io.Writer.
-func (b *Stream) Flush() error {
-	if b.out == nil {
-		return nil
-	}
-	if b.Error != nil {
-		return b.Error
-	}
-	if b.n == 0 {
-		return nil
-	}
-	n, err := b.out.Write(b.buf[0:b.n])
-	if n < b.n && err == nil {
-		err = io.ErrShortWrite
-	}
-	if err != nil {
-		if n > 0 && n < b.n {
-			copy(b.buf[0:b.n-n], b.buf[n:b.n])
-		}
-		b.n -= n
-		b.Error = err
-		return err
-	}
-	b.n = 0
-	return nil
-}
-
-func (b *Stream) ensure(minimal int) {
-	available := b.Available()
-	if available < minimal {
-		if b.n > 1024 {
-			b.Flush()
-		}
-		b.growAtLeast(minimal)
-	}
-}
-
-func (b *Stream) growAtLeast(minimal int) {
-	toGrow := len(b.buf)
-	if toGrow < minimal {
-		toGrow = minimal
-	}
-	newBuf := make([]byte, len(b.buf)+toGrow)
-	copy(newBuf, b.Buffer())
-	b.buf = newBuf
-}
-
-func (b *Stream) WriteRaw(s string) {
-	b.ensure(len(s))
-	if b.Error != nil {
-		return
-	}
-	n := copy(b.buf[b.n:], s)
-	b.n += n
-}
-
-func (stream *Stream) WriteNil() {
-	stream.writeFourBytes('n', 'u', 'l', 'l')
-}
-
-func (stream *Stream) WriteTrue() {
-	stream.writeFourBytes('t', 'r', 'u', 'e')
-}
-
-func (stream *Stream) WriteFalse() {
-	stream.writeFiveBytes('f', 'a', 'l', 's', 'e')
-}
-
-func (stream *Stream) WriteBool(val bool) {
-	if val {
-		stream.WriteTrue()
-	} else {
-		stream.WriteFalse()
-	}
-}
-
-func (stream *Stream) WriteObjectStart() {
-	stream.indention += stream.cfg.indentionStep
-	stream.writeByte('{')
-	stream.writeIndention(0)
-}
-
-func (stream *Stream) WriteObjectField(field string) {
-	stream.WriteString(field)
-	stream.writeByte(':')
-}
-
-func (stream *Stream) WriteObjectEnd() {
-	stream.writeIndention(stream.cfg.indentionStep)
-	stream.indention -= stream.cfg.indentionStep
-	stream.writeByte('}')
-}
-
-func (stream *Stream) WriteEmptyObject() {
-	stream.writeByte('{')
-	stream.writeByte('}')
-}
-
-func (stream *Stream) WriteMore() {
-	stream.writeByte(',')
-	stream.writeIndention(0)
-}
-
-func (stream *Stream) WriteArrayStart() {
-	stream.indention += stream.cfg.indentionStep
-	stream.writeByte('[')
-	stream.writeIndention(0)
-}
-
-func (stream *Stream) WriteEmptyArray() {
-	stream.writeByte('[')
-	stream.writeByte(']')
-}
-
-func (stream *Stream) WriteArrayEnd() {
-	stream.writeIndention(stream.cfg.indentionStep)
-	stream.indention -= stream.cfg.indentionStep
-	stream.writeByte(']')
-}
-
-func (stream *Stream) writeIndention(delta int) {
-	if stream.indention == 0 {
-		return
-	}
-	stream.writeByte('\n')
-	toWrite := stream.indention - delta
-	stream.ensure(toWrite)
-	for i := 0; i < toWrite && stream.n < len(stream.buf); i++ {
-		stream.buf[stream.n] = ' '
-		stream.n++
-	}
-}

feature_stream_float.go

@@ -1,75 +0,0 @@
-package jsoniter
-
-import (
-	"strconv"
-)
-
-var _POW10 []uint64
-
-func init() {
-	_POW10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
-}
-
-func (stream *Stream) WriteFloat32(val float32) {
-	stream.WriteRaw(strconv.FormatFloat(float64(val), 'f', -1, 32))
-}
-
-func (stream *Stream) WriteFloat32Lossy(val float32) {
-	if val < 0 {
-		stream.writeByte('-')
-		val = -val
-	}
-	if val > 0x4ffffff {
-		stream.WriteRaw(strconv.FormatFloat(float64(val), 'f', -1, 32))
-		return
-	}
-	precision := 6
-	exp := uint64(1000000) // 6
-	lval := uint64(float64(val)*float64(exp) + 0.5)
-	stream.WriteUint64(lval / exp)
-	fval := lval % exp
-	if fval == 0 {
-		return
-	}
-	stream.writeByte('.')
-	stream.ensure(10)
-	for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
-		stream.writeByte('0')
-	}
-	stream.WriteUint64(fval)
-	for stream.buf[stream.n-1] == '0' {
-		stream.n--
-	}
-}
-
-func (stream *Stream) WriteFloat64(val float64) {
-	stream.WriteRaw(strconv.FormatFloat(float64(val), 'f', -1, 64))
-}
-
-func (stream *Stream) WriteFloat64Lossy(val float64) {
-	if val < 0 {
-		stream.writeByte('-')
-		val = -val
-	}
-	if val > 0x4ffffff {
-		stream.WriteRaw(strconv.FormatFloat(val, 'f', -1, 64))
-		return
-	}
-	precision := 6
-	exp := uint64(1000000) // 6
-	lval := uint64(val*float64(exp) + 0.5)
-	stream.WriteUint64(lval / exp)
-	fval := lval % exp
-	if fval == 0 {
-		return
-	}
-	stream.writeByte('.')
-	stream.ensure(10)
-	for p := precision - 1; p > 0 && fval < _POW10[p]; p-- {
-		stream.writeByte('0')
-	}
-	stream.WriteUint64(fval)
-	for stream.buf[stream.n-1] == '0' {
-		stream.n--
-	}
-}

feature_stream_int.go

@@ -1,310 +0,0 @@
-package jsoniter
-
-var _DIGITS []uint32
-
-func init() {
-	_DIGITS = make([]uint32, 1000)
-	for i := uint32(0); i < 1000; i++ {
-		_DIGITS[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
-		if i < 10 {
-			_DIGITS[i] += 2 << 24
-		} else if i < 100 {
-			_DIGITS[i] += 1 << 24
-		}
-	}
-}
-
-func writeFirstBuf(buf []byte, v uint32, n int) int {
-	start := v >> 24
-	if start == 0 {
-		buf[n] = byte(v >> 16)
-		n++
-		buf[n] = byte(v >> 8)
-		n++
-	} else if start == 1 {
-		buf[n] = byte(v >> 8)
-		n++
-	}
-	buf[n] = byte(v)
-	n++
-	return n
-}
-
-func writeBuf(buf []byte, v uint32, n int) {
-	buf[n] = byte(v >> 16)
-	buf[n+1] = byte(v >> 8)
-	buf[n+2] = byte(v)
-}
-
-func (stream *Stream) WriteUint8(val uint8) {
-	stream.ensure(3)
-	stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
-}
-
-func (stream *Stream) WriteInt8(nval int8) {
-	stream.ensure(4)
-	n := stream.n
-	var val uint8
-	if nval < 0 {
-		val = uint8(-nval)
-		stream.buf[n] = '-'
-		n++
-	} else {
-		val = uint8(nval)
-	}
-	stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
-}
-
-func (stream *Stream) WriteUint16(val uint16) {
-	stream.ensure(5)
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], stream.n)
-		return
-	}
-	r1 := val - q1*1000
-	n := writeFirstBuf(stream.buf, _DIGITS[q1], stream.n)
-	writeBuf(stream.buf, _DIGITS[r1], n)
-	stream.n = n + 3
-	return
-}
-
-func (stream *Stream) WriteInt16(nval int16) {
-	stream.ensure(6)
-	n := stream.n
-	var val uint16
-	if nval < 0 {
-		val = uint16(-nval)
-		stream.buf[n] = '-'
-		n++
-	} else {
-		val = uint16(nval)
-	}
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	n = writeFirstBuf(stream.buf, _DIGITS[q1], n)
-	writeBuf(stream.buf, _DIGITS[r1], n)
-	stream.n = n + 3
-	return
-}
-
-func (stream *Stream) WriteUint32(val uint32) {
-	stream.ensure(10)
-	n := stream.n
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	q2 := q1 / 1000
-	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
-		stream.n = n + 3
-		return
-	}
-	r2 := q1 - q2*1000
-	q3 := q2 / 1000
-	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
-	} else {
-		r3 := q2 - q3*1000
-		stream.buf[n] = byte(q3 + '0')
-		n++
-		writeBuf(stream.buf, _DIGITS[r3], n)
-		n += 3
-	}
-	writeBuf(stream.buf, _DIGITS[r2], n)
-	writeBuf(stream.buf, _DIGITS[r1], n+3)
-	stream.n = n + 6
-}
-
-func (stream *Stream) WriteInt32(nval int32) {
-	stream.ensure(11)
-	n := stream.n
-	var val uint32
-	if nval < 0 {
-		val = uint32(-nval)
-		stream.buf[n] = '-'
-		n++
-	} else {
-		val = uint32(nval)
-	}
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	q2 := q1 / 1000
-	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
-		stream.n = n + 3
-		return
-	}
-	r2 := q1 - q2*1000
-	q3 := q2 / 1000
-	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
-	} else {
-		r3 := q2 - q3*1000
-		stream.buf[n] = byte(q3 + '0')
-		n++
-		writeBuf(stream.buf, _DIGITS[r3], n)
-		n += 3
-	}
-	writeBuf(stream.buf, _DIGITS[r2], n)
-	writeBuf(stream.buf, _DIGITS[r1], n+3)
-	stream.n = n + 6
-}
-
-func (stream *Stream) WriteUint64(val uint64) {
-	stream.ensure(20)
-	n := stream.n
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	q2 := q1 / 1000
-	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
-		stream.n = n + 3
-		return
-	}
-	r2 := q1 - q2*1000
-	q3 := q2 / 1000
-	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
-		writeBuf(stream.buf, _DIGITS[r2], n)
-		writeBuf(stream.buf, _DIGITS[r1], n+3)
-		stream.n = n + 6
-		return
-	}
-	r3 := q2 - q3*1000
-	q4 := q3 / 1000
-	if q4 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
-		writeBuf(stream.buf, _DIGITS[r3], n)
-		writeBuf(stream.buf, _DIGITS[r2], n+3)
-		writeBuf(stream.buf, _DIGITS[r1], n+6)
-		stream.n = n + 9
-		return
-	}
-	r4 := q3 - q4*1000
-	q5 := q4 / 1000
-	if q5 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
-		writeBuf(stream.buf, _DIGITS[r4], n)
-		writeBuf(stream.buf, _DIGITS[r3], n+3)
-		writeBuf(stream.buf, _DIGITS[r2], n+6)
-		writeBuf(stream.buf, _DIGITS[r1], n+9)
-		stream.n = n + 12
-		return
-	}
-	r5 := q4 - q5*1000
-	q6 := q5 / 1000
-	if q6 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
-	} else {
-		n = writeFirstBuf(stream.buf, _DIGITS[q6], n)
-		r6 := q5 - q6*1000
-		writeBuf(stream.buf, _DIGITS[r6], n)
-		n += 3
-	}
-	writeBuf(stream.buf, _DIGITS[r5], n)
-	writeBuf(stream.buf, _DIGITS[r4], n+3)
-	writeBuf(stream.buf, _DIGITS[r3], n+6)
-	writeBuf(stream.buf, _DIGITS[r2], n+9)
-	writeBuf(stream.buf, _DIGITS[r1], n+12)
-	stream.n = n + 15
-}
-
-func (stream *Stream) WriteInt64(nval int64) {
-	stream.ensure(20)
-	n := stream.n
-	var val uint64
-	if nval < 0 {
-		val = uint64(-nval)
-		stream.buf[n] = '-'
-		n++
-	} else {
-		val = uint64(nval)
-	}
-	q1 := val / 1000
-	if q1 == 0 {
-		stream.n = writeFirstBuf(stream.buf, _DIGITS[val], n)
-		return
-	}
-	r1 := val - q1*1000
-	q2 := q1 / 1000
-	if q2 == 0 {
-		n := writeFirstBuf(stream.buf, _DIGITS[q1], n)
-		writeBuf(stream.buf, _DIGITS[r1], n)
-		stream.n = n + 3
-		return
-	}
-	r2 := q1 - q2*1000
-	q3 := q2 / 1000
-	if q3 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q2], n)
-		writeBuf(stream.buf, _DIGITS[r2], n)
-		writeBuf(stream.buf, _DIGITS[r1], n+3)
-		stream.n = n + 6
-		return
-	}
-	r3 := q2 - q3*1000
-	q4 := q3 / 1000
-	if q4 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q3], n)
-		writeBuf(stream.buf, _DIGITS[r3], n)
-		writeBuf(stream.buf, _DIGITS[r2], n+3)
-		writeBuf(stream.buf, _DIGITS[r1], n+6)
-		stream.n = n + 9
-		return
-	}
-	r4 := q3 - q4*1000
-	q5 := q4 / 1000
-	if q5 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q4], n)
-		writeBuf(stream.buf, _DIGITS[r4], n)
-		writeBuf(stream.buf, _DIGITS[r3], n+3)
-		writeBuf(stream.buf, _DIGITS[r2], n+6)
-		writeBuf(stream.buf, _DIGITS[r1], n+9)
-		stream.n = n + 12
-		return
-	}
-	r5 := q4 - q5*1000
-	q6 := q5 / 1000
-	if q6 == 0 {
-		n = writeFirstBuf(stream.buf, _DIGITS[q5], n)
-	} else {
-		stream.buf[n] = byte(q6 + '0')
-		n++
-		r6 := q5 - q6*1000
-		writeBuf(stream.buf, _DIGITS[r6], n)
-		n += 3
-	}
-	writeBuf(stream.buf, _DIGITS[r5], n)
-	writeBuf(stream.buf, _DIGITS[r4], n+3)
-	writeBuf(stream.buf, _DIGITS[r3], n+6)
-	writeBuf(stream.buf, _DIGITS[r2], n+9)
-	writeBuf(stream.buf, _DIGITS[r1], n+12)
-	stream.n = n + 15
-}
-
-func (stream *Stream) WriteInt(val int) {
-	stream.WriteInt64(int64(val))
-}
-
-func (stream *Stream) WriteUint(val uint) {
-	stream.WriteUint64(uint64(val))
-}

fuzzy_mode_convert_table.md

@@ -0,0 +1,7 @@
+| json type \ dest type | bool | int | uint | float |string|
+| --- | --- | --- | --- |--|--|
+| number | positive => true <br/> negative => true <br/> zero => false| 23.2 => 23 <br/> -32.1 => -32| 12.1 => 12 <br/> -12.1 => 0|as normal|same as origin|
+| string | empty string => false <br/> string "0" => false <br/> other strings => true | "123.32" => 123 <br/> "-123.4" => -123 <br/> "123.23xxxw" => 123 <br/>  "abcde12" => 0 <br/> "-32.1" => -32| 13.2 => 13 <br/> -1.1 => 0 |12.1 => 12.1 <br/> -12.3 => -12.3<br/> 12.4xxa => 12.4 <br/> +1.1e2 =>110 |same as origin|
+| bool | true => true <br/> false => false| true => 1 <br/> false => 0 | true => 1 <br/> false => 0 |true => 1 <br/>false => 0|true => "true" <br/> false => "false"|
+| object | true | 0 | 0 |0|originnal json|
+| array | empty array => false <br/> nonempty array => true| [] => 0 <br/> [1,2] => 1 | [] => 0 <br/> [1,2] => 1 |[] => 0<br/>[1,2] => 1|original json|

iter.go

@@ -1,26 +1,29 @@
-//
-// Besides, jsoniter.Iterator provides a different set of interfaces
-// iterating given bytes/string/reader
-// and yielding parsed elements one by one.
-// This set of interfaces reads input as required and gives
-// better performance.
 package jsoniter
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 )
 
+// ValueType the type for JSON element
 type ValueType int
 
 const (
-	Invalid ValueType = iota
-	String
-	Number
-	Nil
-	Bool
-	Array
-	Object
+	// InvalidValue invalid JSON element
+	InvalidValue ValueType = iota
+	// StringValue JSON element "string"
+	StringValue
+	// NumberValue JSON element 100 or 0.10
+	NumberValue
+	// NilValue JSON element null
+	NilValue
+	// BoolValue JSON element true or false
+	BoolValue
+	// ArrayValue JSON element []
+	ArrayValue
+	// ObjectValue JSON element {}
+	ObjectValue
 )
 
 var hexDigits []byte
@@ -42,28 +45,29 @@ func init() {
 	}
 	valueTypes = make([]ValueType, 256)
 	for i := 0; i < len(valueTypes); i++ {
-		valueTypes[i] = Invalid
+		valueTypes[i] = InvalidValue
 	}
-	valueTypes['"'] = String
-	valueTypes['-'] = Number
-	valueTypes['0'] = Number
-	valueTypes['1'] = Number
-	valueTypes['2'] = Number
-	valueTypes['3'] = Number
-	valueTypes['4'] = Number
-	valueTypes['5'] = Number
-	valueTypes['6'] = Number
-	valueTypes['7'] = Number
-	valueTypes['8'] = Number
-	valueTypes['9'] = Number
-	valueTypes['t'] = Bool
-	valueTypes['f'] = Bool
-	valueTypes['n'] = Nil
-	valueTypes['['] = Array
-	valueTypes['{'] = Object
+	valueTypes['"'] = StringValue
+	valueTypes['-'] = NumberValue
+	valueTypes['0'] = NumberValue
+	valueTypes['1'] = NumberValue
+	valueTypes['2'] = NumberValue
+	valueTypes['3'] = NumberValue
+	valueTypes['4'] = NumberValue
+	valueTypes['5'] = NumberValue
+	valueTypes['6'] = NumberValue
+	valueTypes['7'] = NumberValue
+	valueTypes['8'] = NumberValue
+	valueTypes['9'] = NumberValue
+	valueTypes['t'] = BoolValue
+	valueTypes['f'] = BoolValue
+	valueTypes['n'] = NilValue
+	valueTypes['['] = ArrayValue
+	valueTypes['{'] = ObjectValue
 }
 
-// Iterator is a fast and flexible JSON parser
+// Iterator is a io.Reader like object, with JSON specific read functions.
+// Error is not returned as return value, but stored as Error member on this iterator instance.
 type Iterator struct {
 	cfg              *frozenConfig
 	reader           io.Reader
@@ -73,12 +77,13 @@ type Iterator struct {
 	captureStartedAt int
 	captured         []byte
 	Error            error
+	Attachment       interface{} // open for customized decoder
 }
 
-// Create creates an empty Iterator instance
-func NewIterator(cfg *frozenConfig) *Iterator {
+// NewIterator creates an empty Iterator instance
+func NewIterator(cfg API) *Iterator {
 	return &Iterator{
-		cfg:    cfg,
+		cfg:    cfg.(*frozenConfig),
 		reader: nil,
 		buf:    nil,
 		head:   0,
@@ -86,10 +91,10 @@ func NewIterator(cfg *frozenConfig) *Iterator {
 	}
 }
 
-// Parse parses a json buffer in io.Reader into an Iterator instance
-func Parse(cfg *frozenConfig, reader io.Reader, bufSize int) *Iterator {
+// Parse creates an Iterator instance from io.Reader
+func Parse(cfg API, reader io.Reader, bufSize int) *Iterator {
 	return &Iterator{
-		cfg:    cfg,
+		cfg:    cfg.(*frozenConfig),
 		reader: reader,
 		buf:    make([]byte, bufSize),
 		head:   0,
@@ -97,10 +102,10 @@ func Parse(cfg *frozenConfig, reader io.Reader, bufSize int) *Iterator {
 	}
 }
 
-// ParseBytes parses a json byte slice into an Iterator instance
-func ParseBytes(cfg *frozenConfig, input []byte) *Iterator {
+// ParseBytes creates an Iterator instance from byte array
+func ParseBytes(cfg API, input []byte) *Iterator {
 	return &Iterator{
-		cfg:    cfg,
+		cfg:    cfg.(*frozenConfig),
 		reader: nil,
 		buf:    input,
 		head:   0,
@@ -108,16 +113,17 @@ func ParseBytes(cfg *frozenConfig, input []byte) *Iterator {
 	}
 }
 
-// ParseString parses a json string into an Iterator instance
-func ParseString(cfg *frozenConfig, input string) *Iterator {
+// ParseString creates an Iterator instance from string
+func ParseString(cfg API, input string) *Iterator {
 	return ParseBytes(cfg, []byte(input))
 }
 
-func (iter *Iterator) Config() *frozenConfig {
+// Pool returns a pool can provide more iterator with same configuration
+func (iter *Iterator) Pool() IteratorPool {
 	return iter.cfg
 }
 
-// Reset can reset an Iterator instance for another json buffer in io.Reader
+// Reset reuse iterator instance by specifying another reader
 func (iter *Iterator) Reset(reader io.Reader) *Iterator {
 	iter.reader = reader
 	iter.head = 0
@@ -125,7 +131,7 @@ func (iter *Iterator) Reset(reader io.Reader) *Iterator {
 	return iter
 }
 
-// ResetBytes can reset an Iterator instance for another json byte slice
+// ResetBytes reuse iterator instance by specifying another byte array as input
 func (iter *Iterator) ResetBytes(input []byte) *Iterator {
 	iter.reader = nil
 	iter.buf = input
@@ -134,7 +140,7 @@ func (iter *Iterator) ResetBytes(input []byte) *Iterator {
 	return iter
 }
 
-// WhatIsNext gets ValueType of relatively next json object
+// WhatIsNext gets ValueType of relatively next json element
 func (iter *Iterator) WhatIsNext() ValueType {
 	valueType := valueTypes[iter.nextToken()]
 	iter.unreadByte()
@@ -154,6 +160,18 @@ func (iter *Iterator) skipWhitespacesWithoutLoadMore() bool {
 	return true
 }
 
+func (iter *Iterator) isObjectEnd() bool {
+	c := iter.nextToken()
+	if c == ',' {
+		return false
+	}
+	if c == '}' {
+		return true
+	}
+	iter.ReportError("isObjectEnd", "object ended prematurely, unexpected char "+string([]byte{c}))
+	return true
+}
+
 func (iter *Iterator) nextToken() byte {
 	// a variation of skip whitespaces, returning the next non-whitespace token
 	for {
@@ -172,6 +190,7 @@ func (iter *Iterator) nextToken() byte {
 	}
 }
 
+// ReportError record a error in iterator instance with current position.
 func (iter *Iterator) ReportError(operation string, msg string) {
 	if iter.Error != nil {
 		if iter.Error != io.EOF {
@@ -182,17 +201,31 @@ func (iter *Iterator) ReportError(operation string, msg string) {
 	if peekStart < 0 {
 		peekStart = 0
 	}
-	iter.Error = fmt.Errorf("%s: %s, parsing %v ...%s... at %s", operation, msg, iter.head,
-		string(iter.buf[peekStart:iter.head]), string(iter.buf[0:iter.tail]))
+	peekEnd := iter.head + 10
+	if peekEnd > iter.tail {
+		peekEnd = iter.tail
+	}
+	parsing := string(iter.buf[peekStart:peekEnd])
+	contextStart := iter.head - 50
+	if contextStart < 0 {
+		contextStart = 0
+	}
+	contextEnd := iter.head + 50
+	if contextEnd > iter.tail {
+		contextEnd = iter.tail
+	}
+	context := string(iter.buf[contextStart:contextEnd])
+	iter.Error = fmt.Errorf("%s: %s, error found in #%v byte of ...|%s|..., bigger context ...|%s|...",
+		operation, msg, iter.head-peekStart, parsing, context)
 }
 
-// CurrentBuffer gets current buffer as string
+// CurrentBuffer gets current buffer as string for debugging purpose
 func (iter *Iterator) CurrentBuffer() string {
 	peekStart := iter.head - 10
 	if peekStart < 0 {
 		peekStart = 0
 	}
-	return fmt.Sprintf("parsing %v ...|%s|... at %s", iter.head,
+	return fmt.Sprintf("parsing #%v byte, around ...|%s|..., whole buffer ...|%s|...", iter.head,
 		string(iter.buf[peekStart:iter.head]), string(iter.buf[0:iter.tail]))
 }
 
@@ -218,7 +251,7 @@ func (iter *Iterator) loadMore() bool {
 		}
 		return false
 	}
-	if iter.captureStartedAt != -1 {
+	if iter.captured != nil {
 		iter.captured = append(iter.captured,
 			iter.buf[iter.captureStartedAt:iter.tail]...)
 		iter.captureStartedAt = 0
@@ -241,37 +274,44 @@ func (iter *Iterator) loadMore() bool {
 }
 
 func (iter *Iterator) unreadByte() {
-	if iter.head == 0 {
-		iter.ReportError("unreadByte", "unread too many bytes")
+	if iter.Error != nil {
 		return
 	}
 	iter.head--
 	return
 }
 
+// Read read the next JSON element as generic interface{}.
 func (iter *Iterator) Read() interface{} {
 	valueType := iter.WhatIsNext()
 	switch valueType {
-	case String:
+	case StringValue:
 		return iter.ReadString()
-	case Number:
+	case NumberValue:
+		if iter.cfg.configBeforeFrozen.UseNumber {
+			return json.Number(iter.readNumberAsString())
+		}
 		return iter.ReadFloat64()
-	case Nil:
-		iter.skipFixedBytes(4) // null
+	case NilValue:
+		iter.skipFourBytes('n', 'u', 'l', 'l')
 		return nil
-	case Bool:
+	case BoolValue:
 		return iter.ReadBool()
-	case Array:
+	case ArrayValue:
 		arr := []interface{}{}
 		iter.ReadArrayCB(func(iter *Iterator) bool {
-			arr = append(arr, iter.Read())
+			var elem interface{}
+			iter.ReadVal(&elem)
+			arr = append(arr, elem)
 			return true
 		})
 		return arr
-	case Object:
+	case ObjectValue:
 		obj := map[string]interface{}{}
-		iter.ReadObjectCB(func(Iter *Iterator, field string) bool {
-			obj[field] = iter.Read()
+		iter.ReadMapCB(func(Iter *Iterator, field string) bool {
+			var elem interface{}
+			iter.ReadVal(&elem)
+			obj[field] = elem
 			return true
 		})
 		return obj

iter_array.go

@@ -1,10 +1,11 @@
 package jsoniter
 
+// ReadArray read array element, tells if the array has more element to read.
 func (iter *Iterator) ReadArray() (ret bool) {
 	c := iter.nextToken()
 	switch c {
 	case 'n':
-		iter.skipFixedBytes(3)
+		iter.skipThreeBytes('u', 'l', 'l')
 		return false // null
 	case '[':
 		c = iter.nextToken()
@@ -18,11 +19,12 @@ func (iter *Iterator) ReadArray() (ret bool) {
 	case ',':
 		return true
 	default:
-		iter.ReportError("ReadArray", "expect [ or , or ] or n, but found: "+string([]byte{c}))
+		iter.ReportError("ReadArray", "expect [ or , or ] or n, but found "+string([]byte{c}))
 		return
 	}
 }
 
+// ReadArrayCB read array with callback
 func (iter *Iterator) ReadArrayCB(callback func(*Iterator) bool) (ret bool) {
 	c := iter.nextToken()
 	if c == '[' {
@@ -32,19 +34,25 @@ func (iter *Iterator) ReadArrayCB(callback func(*Iterator) bool) (ret bool) {
 			if !callback(iter) {
 				return false
 			}
-			for iter.nextToken() == ',' {
+			c = iter.nextToken()
+			for c == ',' {
 				if !callback(iter) {
 					return false
 				}
+				c = iter.nextToken()
+			}
+			if c != ']' {
+				iter.ReportError("ReadArrayCB", "expect ] in the end, but found "+string([]byte{c}))
+				return false
 			}
 			return true
 		}
 		return true
 	}
 	if c == 'n' {
-		iter.skipFixedBytes(3)
+		iter.skipThreeBytes('u', 'l', 'l')
 		return true // null
 	}
-	iter.ReportError("ReadArrayCB", "expect [ or n, but found: "+string([]byte{c}))
+	iter.ReportError("ReadArrayCB", "expect [ or n, but found "+string([]byte{c}))
 	return false
 }

iter_float.go

@@ -1,9 +1,11 @@
 package jsoniter
 
 import (
+	"encoding/json"
 	"io"
 	"math/big"
 	"strconv"
+	"strings"
 	"unsafe"
 )
 
@@ -30,6 +32,7 @@ func init() {
 	floatDigits['.'] = dotInNumber
 }
 
+// ReadBigFloat read big.Float
 func (iter *Iterator) ReadBigFloat() (ret *big.Float) {
 	str := iter.readNumberAsString()
 	if iter.Error != nil && iter.Error != io.EOF {
@@ -47,6 +50,7 @@ func (iter *Iterator) ReadBigFloat() (ret *big.Float) {
 	return val
 }
 
+// ReadBigInt read big.Int
 func (iter *Iterator) ReadBigInt() (ret *big.Int) {
 	str := iter.readNumberAsString()
 	if iter.Error != nil && iter.Error != io.EOF {
@@ -62,20 +66,49 @@ func (iter *Iterator) ReadBigInt() (ret *big.Int) {
 	return ret
 }
 
+//ReadFloat32 read float32
 func (iter *Iterator) ReadFloat32() (ret float32) {
 	c := iter.nextToken()
 	if c == '-' {
 		return -iter.readPositiveFloat32()
-	} else {
-		iter.unreadByte()
-		return iter.readPositiveFloat32()
 	}
+	iter.unreadByte()
+	return iter.readPositiveFloat32()
 }
 
 func (iter *Iterator) readPositiveFloat32() (ret float32) {
 	value := uint64(0)
 	c := byte(' ')
 	i := iter.head
+	// first char
+	if i == iter.tail {
+		return iter.readFloat32SlowPath()
+	}
+	c = iter.buf[i]
+	i++
+	ind := floatDigits[c]
+	switch ind {
+	case invalidCharForNumber:
+		return iter.readFloat32SlowPath()
+	case endOfNumber:
+		iter.ReportError("readFloat32", "empty number")
+		return
+	case dotInNumber:
+		iter.ReportError("readFloat32", "leading dot is invalid")
+		return
+	case 0:
+		if i == iter.tail {
+			return iter.readFloat32SlowPath()
+		}
+		c = iter.buf[i]
+		switch c {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			iter.ReportError("readFloat32", "leading zero is invalid")
+			return
+		}
+	}
+	value = uint64(ind)
+	// chars before dot
 non_decimal_loop:
 	for ; i < iter.tail; i++ {
 		c = iter.buf[i]
@@ -94,17 +127,21 @@ non_decimal_loop:
 		}
 		value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
 	}
+	// chars after dot
 	if c == '.' {
 		i++
 		decimalPlaces := 0
+		if i == iter.tail {
+			return iter.readFloat32SlowPath()
+		}
 		for ; i < iter.tail; i++ {
 			c = iter.buf[i]
 			ind := floatDigits[c]
 			switch ind {
 			case endOfNumber:
-				if decimalPlaces > 0 && decimalPlaces < len(_POW10) {
+				if decimalPlaces > 0 && decimalPlaces < len(pow10) {
 					iter.head = i
-					return float32(float64(value) / float64(_POW10[decimalPlaces]))
+					return float32(float64(value) / float64(pow10[decimalPlaces]))
 				}
 				// too many decimal places
 				return iter.readFloat32SlowPath()
@@ -131,7 +168,7 @@ load_loop:
 		for i := iter.head; i < iter.tail; i++ {
 			c := iter.buf[i]
 			switch c {
-			case '-', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			case '+', '-', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
 				str = append(str, c)
 				continue
 			default:
@@ -157,6 +194,11 @@ func (iter *Iterator) readFloat32SlowPath() (ret float32) {
 	if iter.Error != nil && iter.Error != io.EOF {
 		return
 	}
+	errMsg := validateFloat(str)
+	if errMsg != "" {
+		iter.ReportError("readFloat32SlowPath", errMsg)
+		return
+	}
 	val, err := strconv.ParseFloat(str, 32)
 	if err != nil {
 		iter.Error = err
@@ -165,20 +207,49 @@ func (iter *Iterator) readFloat32SlowPath() (ret float32) {
 	return float32(val)
 }
 
+// ReadFloat64 read float64
 func (iter *Iterator) ReadFloat64() (ret float64) {
 	c := iter.nextToken()
 	if c == '-' {
 		return -iter.readPositiveFloat64()
-	} else {
-		iter.unreadByte()
-		return iter.readPositiveFloat64()
 	}
+	iter.unreadByte()
+	return iter.readPositiveFloat64()
 }
 
 func (iter *Iterator) readPositiveFloat64() (ret float64) {
 	value := uint64(0)
 	c := byte(' ')
 	i := iter.head
+	// first char
+	if i == iter.tail {
+		return iter.readFloat64SlowPath()
+	}
+	c = iter.buf[i]
+	i++
+	ind := floatDigits[c]
+	switch ind {
+	case invalidCharForNumber:
+		return iter.readFloat64SlowPath()
+	case endOfNumber:
+		iter.ReportError("readFloat64", "empty number")
+		return
+	case dotInNumber:
+		iter.ReportError("readFloat64", "leading dot is invalid")
+		return
+	case 0:
+		if i == iter.tail {
+			return iter.readFloat64SlowPath()
+		}
+		c = iter.buf[i]
+		switch c {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			iter.ReportError("readFloat64", "leading zero is invalid")
+			return
+		}
+	}
+	value = uint64(ind)
+	// chars before dot
 non_decimal_loop:
 	for ; i < iter.tail; i++ {
 		c = iter.buf[i]
@@ -197,17 +268,21 @@ non_decimal_loop:
 		}
 		value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
 	}
+	// chars after dot
 	if c == '.' {
 		i++
 		decimalPlaces := 0
+		if i == iter.tail {
+			return iter.readFloat64SlowPath()
+		}
 		for ; i < iter.tail; i++ {
 			c = iter.buf[i]
 			ind := floatDigits[c]
 			switch ind {
 			case endOfNumber:
-				if decimalPlaces > 0 && decimalPlaces < len(_POW10) {
+				if decimalPlaces > 0 && decimalPlaces < len(pow10) {
 					iter.head = i
-					return float64(value) / float64(_POW10[decimalPlaces])
+					return float64(value) / float64(pow10[decimalPlaces])
 				}
 				// too many decimal places
 				return iter.readFloat64SlowPath()
@@ -231,6 +306,11 @@ func (iter *Iterator) readFloat64SlowPath() (ret float64) {
 	if iter.Error != nil && iter.Error != io.EOF {
 		return
 	}
+	errMsg := validateFloat(str)
+	if errMsg != "" {
+		iter.ReportError("readFloat64SlowPath", errMsg)
+		return
+	}
 	val, err := strconv.ParseFloat(str, 64)
 	if err != nil {
 		iter.Error = err
@@ -238,3 +318,30 @@ func (iter *Iterator) readFloat64SlowPath() (ret float64) {
 	}
 	return val
 }
+
+func validateFloat(str string) string {
+	// strconv.ParseFloat is not validating `1.` or `1.e1`
+	if len(str) == 0 {
+		return "empty number"
+	}
+	if str[0] == '-' {
+		return "-- is not valid"
+	}
+	dotPos := strings.IndexByte(str, '.')
+	if dotPos != -1 {
+		if dotPos == len(str)-1 {
+			return "dot can not be last character"
+		}
+		switch str[dotPos+1] {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		default:
+			return "missing digit after dot"
+		}
+	}
+	return ""
+}
+
+// ReadNumber read json.Number
+func (iter *Iterator) ReadNumber() (ret json.Number) {
+	return json.Number(iter.readNumberAsString())
+}

iter_int.go

@@ -20,14 +20,23 @@ func init() {
 	}
 }
 
+// ReadUint read uint
 func (iter *Iterator) ReadUint() uint {
+	if strconv.IntSize == 32 {
+		return uint(iter.ReadUint32())
+	}
 	return uint(iter.ReadUint64())
 }
 
+// ReadInt read int
 func (iter *Iterator) ReadInt() int {
+	if strconv.IntSize == 32 {
+		return int(iter.ReadInt32())
+	}
 	return int(iter.ReadInt64())
 }
 
+// ReadInt8 read int8
 func (iter *Iterator) ReadInt8() (ret int8) {
 	c := iter.nextToken()
 	if c == '-' {
@@ -37,16 +46,16 @@ func (iter *Iterator) ReadInt8() (ret int8) {
 			return
 		}
 		return -int8(val)
-	} else {
-		val := iter.readUint32(c)
-		if val > math.MaxInt8 {
-			iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
-			return
-		}
-		return int8(val)
 	}
+	val := iter.readUint32(c)
+	if val > math.MaxInt8 {
+		iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
+		return
+	}
+	return int8(val)
 }
 
+// ReadUint8 read uint8
 func (iter *Iterator) ReadUint8() (ret uint8) {
 	val := iter.readUint32(iter.nextToken())
 	if val > math.MaxUint8 {
@@ -56,6 +65,7 @@ func (iter *Iterator) ReadUint8() (ret uint8) {
 	return uint8(val)
 }
 
+// ReadInt16 read int16
 func (iter *Iterator) ReadInt16() (ret int16) {
 	c := iter.nextToken()
 	if c == '-' {
@@ -65,16 +75,16 @@ func (iter *Iterator) ReadInt16() (ret int16) {
 			return
 		}
 		return -int16(val)
-	} else {
-		val := iter.readUint32(c)
-		if val > math.MaxInt16 {
-			iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
-			return
-		}
-		return int16(val)
 	}
+	val := iter.readUint32(c)
+	if val > math.MaxInt16 {
+		iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
+		return
+	}
+	return int16(val)
 }
 
+// ReadUint16 read uint16
 func (iter *Iterator) ReadUint16() (ret uint16) {
 	val := iter.readUint32(iter.nextToken())
 	if val > math.MaxUint16 {
@@ -84,6 +94,7 @@ func (iter *Iterator) ReadUint16() (ret uint16) {
 	return uint16(val)
 }
 
+// ReadInt32 read int32
 func (iter *Iterator) ReadInt32() (ret int32) {
 	c := iter.nextToken()
 	if c == '-' {
@@ -93,16 +104,16 @@ func (iter *Iterator) ReadInt32() (ret int32) {
 			return
 		}
 		return -int32(val)
-	} else {
-		val := iter.readUint32(c)
-		if val > math.MaxInt32 {
-			iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
-			return
-		}
-		return int32(val)
 	}
+	val := iter.readUint32(c)
+	if val > math.MaxInt32 {
+		iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
+		return
+	}
+	return int32(val)
 }
 
+// ReadUint32 read uint32
 func (iter *Iterator) ReadUint32() (ret uint32) {
 	return iter.readUint32(iter.nextToken())
 }
@@ -110,6 +121,7 @@ func (iter *Iterator) ReadUint32() (ret uint32) {
 func (iter *Iterator) readUint32(c byte) (ret uint32) {
 	ind := intDigits[c]
 	if ind == 0 {
+		iter.assertInteger()
 		return 0 // single zero
 	}
 	if ind == invalidCharForNumber {
@@ -122,12 +134,14 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		ind2 := intDigits[iter.buf[i]]
 		if ind2 == invalidCharForNumber {
 			iter.head = i
+			iter.assertInteger()
 			return value
 		}
 		i++
 		ind3 := intDigits[iter.buf[i]]
 		if ind3 == invalidCharForNumber {
 			iter.head = i
+			iter.assertInteger()
 			return value*10 + uint32(ind2)
 		}
 		//iter.head = i + 1
@@ -136,30 +150,35 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		ind4 := intDigits[iter.buf[i]]
 		if ind4 == invalidCharForNumber {
 			iter.head = i
+			iter.assertInteger()
 			return value*100 + uint32(ind2)*10 + uint32(ind3)
 		}
 		i++
 		ind5 := intDigits[iter.buf[i]]
 		if ind5 == invalidCharForNumber {
 			iter.head = i
+			iter.assertInteger()
 			return value*1000 + uint32(ind2)*100 + uint32(ind3)*10 + uint32(ind4)
 		}
 		i++
 		ind6 := intDigits[iter.buf[i]]
 		if ind6 == invalidCharForNumber {
 			iter.head = i
+			iter.assertInteger()
 			return value*10000 + uint32(ind2)*1000 + uint32(ind3)*100 + uint32(ind4)*10 + uint32(ind5)
 		}
 		i++
 		ind7 := intDigits[iter.buf[i]]
 		if ind7 == invalidCharForNumber {
 			iter.head = i
+			iter.assertInteger()
 			return value*100000 + uint32(ind2)*10000 + uint32(ind3)*1000 + uint32(ind4)*100 + uint32(ind5)*10 + uint32(ind6)
 		}
 		i++
 		ind8 := intDigits[iter.buf[i]]
 		if ind8 == invalidCharForNumber {
 			iter.head = i
+			iter.assertInteger()
 			return value*1000000 + uint32(ind2)*100000 + uint32(ind3)*10000 + uint32(ind4)*1000 + uint32(ind5)*100 + uint32(ind6)*10 + uint32(ind7)
 		}
 		i++
@@ -167,6 +186,7 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 		value = value*10000000 + uint32(ind2)*1000000 + uint32(ind3)*100000 + uint32(ind4)*10000 + uint32(ind5)*1000 + uint32(ind6)*100 + uint32(ind7)*10 + uint32(ind8)
 		iter.head = i
 		if ind9 == invalidCharForNumber {
+			iter.assertInteger()
 			return value
 		}
 	}
@@ -175,6 +195,7 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 			ind = intDigits[iter.buf[i]]
 			if ind == invalidCharForNumber {
 				iter.head = i
+				iter.assertInteger()
 				return value
 			}
 			if value > uint32SafeToMultiply10 {
@@ -182,19 +203,20 @@ func (iter *Iterator) readUint32(c byte) (ret uint32) {
 				if value2 < value {
 					iter.ReportError("readUint32", "overflow")
 					return
-				} else {
-					value = value2
-					continue
 				}
+				value = value2
+				continue
 			}
 			value = (value << 3) + (value << 1) + uint32(ind)
 		}
 		if !iter.loadMore() {
+			iter.assertInteger()
 			return value
 		}
 	}
 }
 
+// ReadInt64 read int64
 func (iter *Iterator) ReadInt64() (ret int64) {
 	c := iter.nextToken()
 	if c == '-' {
@@ -204,16 +226,16 @@ func (iter *Iterator) ReadInt64() (ret int64) {
 			return
 		}
 		return -int64(val)
-	} else {
-		val := iter.readUint64(c)
-		if val > math.MaxInt64 {
-			iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
-			return
-		}
-		return int64(val)
 	}
+	val := iter.readUint64(c)
+	if val > math.MaxInt64 {
+		iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
+		return
+	}
+	return int64(val)
 }
 
+// ReadUint64 read uint64
 func (iter *Iterator) ReadUint64() uint64 {
 	return iter.readUint64(iter.nextToken())
 }
@@ -221,6 +243,7 @@ func (iter *Iterator) ReadUint64() uint64 {
 func (iter *Iterator) readUint64(c byte) (ret uint64) {
 	ind := intDigits[c]
 	if ind == 0 {
+		iter.assertInteger()
 		return 0 // single zero
 	}
 	if ind == invalidCharForNumber {
@@ -228,11 +251,73 @@ func (iter *Iterator) readUint64(c byte) (ret uint64) {
 		return
 	}
 	value := uint64(ind)
+	if iter.tail-iter.head > 10 {
+		i := iter.head
+		ind2 := intDigits[iter.buf[i]]
+		if ind2 == invalidCharForNumber {
+			iter.head = i
+			iter.assertInteger()
+			return value
+		}
+		i++
+		ind3 := intDigits[iter.buf[i]]
+		if ind3 == invalidCharForNumber {
+			iter.head = i
+			iter.assertInteger()
+			return value*10 + uint64(ind2)
+		}
+		//iter.head = i + 1
+		//value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
+		i++
+		ind4 := intDigits[iter.buf[i]]
+		if ind4 == invalidCharForNumber {
+			iter.head = i
+			iter.assertInteger()
+			return value*100 + uint64(ind2)*10 + uint64(ind3)
+		}
+		i++
+		ind5 := intDigits[iter.buf[i]]
+		if ind5 == invalidCharForNumber {
+			iter.head = i
+			iter.assertInteger()
+			return value*1000 + uint64(ind2)*100 + uint64(ind3)*10 + uint64(ind4)
+		}
+		i++
+		ind6 := intDigits[iter.buf[i]]
+		if ind6 == invalidCharForNumber {
+			iter.head = i
+			iter.assertInteger()
+			return value*10000 + uint64(ind2)*1000 + uint64(ind3)*100 + uint64(ind4)*10 + uint64(ind5)
+		}
+		i++
+		ind7 := intDigits[iter.buf[i]]
+		if ind7 == invalidCharForNumber {
+			iter.head = i
+			iter.assertInteger()
+			return value*100000 + uint64(ind2)*10000 + uint64(ind3)*1000 + uint64(ind4)*100 + uint64(ind5)*10 + uint64(ind6)
+		}
+		i++
+		ind8 := intDigits[iter.buf[i]]
+		if ind8 == invalidCharForNumber {
+			iter.head = i
+			iter.assertInteger()
+			return value*1000000 + uint64(ind2)*100000 + uint64(ind3)*10000 + uint64(ind4)*1000 + uint64(ind5)*100 + uint64(ind6)*10 + uint64(ind7)
+		}
+		i++
+		ind9 := intDigits[iter.buf[i]]
+		value = value*10000000 + uint64(ind2)*1000000 + uint64(ind3)*100000 + uint64(ind4)*10000 + uint64(ind5)*1000 + uint64(ind6)*100 + uint64(ind7)*10 + uint64(ind8)
+		iter.head = i
+		if ind9 == invalidCharForNumber {
+			iter.assertInteger()
+			return value
+		}
+	}
 	for {
 		for i := iter.head; i < iter.tail; i++ {
 			ind = intDigits[iter.buf[i]]
 			if ind == invalidCharForNumber {
 				iter.head = i
+				iter.assertInteger()
 				return value
 			}
 			if value > uint64SafeToMultiple10 {
@@ -240,15 +325,21 @@ func (iter *Iterator) readUint64(c byte) (ret uint64) {
 				if value2 < value {
 					iter.ReportError("readUint64", "overflow")
 					return
-				} else {
-					value = value2
-					continue
 				}
+				value = value2
+				continue
 			}
 			value = (value << 3) + (value << 1) + uint64(ind)
 		}
 		if !iter.loadMore() {
+			iter.assertInteger()
 			return value
 		}
 	}
 }
+
+func (iter *Iterator) assertInteger() {
+	if iter.head < len(iter.buf) && iter.buf[iter.head] == '.' {
+		iter.ReportError("assertInteger", "can not decode float as int")
+	}
+}

iter_object.go

@@ -0,0 +1,248 @@
+package jsoniter
+
+import (
+	"fmt"
+	"unicode"
+)
+
+// ReadObject read one field from object.
+// If object ended, returns empty string.
+// Otherwise, returns the field name.
+func (iter *Iterator) ReadObject() (ret string) {
+	c := iter.nextToken()
+	switch c {
+	case 'n':
+		iter.skipThreeBytes('u', 'l', 'l')
+		return "" // null
+	case '{':
+		c = iter.nextToken()
+		if c == '"' {
+			iter.unreadByte()
+			field := iter.ReadString()
+			c = iter.nextToken()
+			if c != ':' {
+				iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+			}
+			return field
+		}
+		if c == '}' {
+			return "" // end of object
+		}
+		iter.ReportError("ReadObject", `expect " after {, but found `+string([]byte{c}))
+		return
+	case ',':
+		field := iter.ReadString()
+		c = iter.nextToken()
+		if c != ':' {
+			iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+		}
+		return field
+	case '}':
+		return "" // end of object
+	default:
+		iter.ReportError("ReadObject", fmt.Sprintf(`expect { or , or } or n, but found %s`, string([]byte{c})))
+		return
+	}
+}
+
+// CaseInsensitive
+func (iter *Iterator) readFieldHash() int64 {
+	hash := int64(0x811c9dc5)
+	c := iter.nextToken()
+	if c != '"' {
+		iter.ReportError("readFieldHash", `expect ", but found `+string([]byte{c}))
+		return 0
+	}
+	for {
+		for i := iter.head; i < iter.tail; i++ {
+			// require ascii string and no escape
+			b := iter.buf[i]
+			if b == '\\' {
+				iter.head = i
+				for _, b := range iter.readStringSlowPath() {
+					if 'A' <= b && b <= 'Z' {
+						b += 'a' - 'A'
+					}
+					hash ^= int64(b)
+					hash *= 0x1000193
+				}
+				c = iter.nextToken()
+				if c != ':' {
+					iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
+					return 0
+				}
+				return hash
+			}
+			if b == '"' {
+				iter.head = i + 1
+				c = iter.nextToken()
+				if c != ':' {
+					iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
+					return 0
+				}
+				return hash
+			}
+			if 'A' <= b && b <= 'Z' {
+				b += 'a' - 'A'
+			}
+			hash ^= int64(b)
+			hash *= 0x1000193
+		}
+		if !iter.loadMore() {
+			iter.ReportError("readFieldHash", `incomplete field name`)
+			return 0
+		}
+	}
+}
+
+func calcHash(str string) int64 {
+	hash := int64(0x811c9dc5)
+	for _, b := range str {
+		hash ^= int64(unicode.ToLower(b))
+		hash *= 0x1000193
+	}
+	return int64(hash)
+}
+
+// ReadObjectCB read object with callback, the key is ascii only and field name not copied
+func (iter *Iterator) ReadObjectCB(callback func(*Iterator, string) bool) bool {
+	c := iter.nextToken()
+	var field string
+	if c == '{' {
+		c = iter.nextToken()
+		if c == '"' {
+			iter.unreadByte()
+			field = iter.ReadString()
+			c = iter.nextToken()
+			if c != ':' {
+				iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+			}
+			if !callback(iter, field) {
+				return false
+			}
+			c = iter.nextToken()
+			for c == ',' {
+				field = iter.ReadString()
+				c = iter.nextToken()
+				if c != ':' {
+					iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+				}
+				if !callback(iter, field) {
+					return false
+				}
+				c = iter.nextToken()
+			}
+			if c != '}' {
+				iter.ReportError("ReadObjectCB", `object not ended with }`)
+				return false
+			}
+			return true
+		}
+		if c == '}' {
+			return true
+		}
+		iter.ReportError("ReadObjectCB", `expect " after }, but found `+string([]byte{c}))
+		return false
+	}
+	if c == 'n' {
+		iter.skipThreeBytes('u', 'l', 'l')
+		return true // null
+	}
+	iter.ReportError("ReadObjectCB", `expect { or n, but found `+string([]byte{c}))
+	return false
+}
+
+// ReadMapCB read map with callback, the key can be any string
+func (iter *Iterator) ReadMapCB(callback func(*Iterator, string) bool) bool {
+	c := iter.nextToken()
+	if c == '{' {
+		c = iter.nextToken()
+		if c == '"' {
+			iter.unreadByte()
+			field := iter.ReadString()
+			if iter.nextToken() != ':' {
+				iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
+				return false
+			}
+			if !callback(iter, field) {
+				return false
+			}
+			c = iter.nextToken()
+			for c == ',' {
+				field = iter.ReadString()
+				if iter.nextToken() != ':' {
+					iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
+					return false
+				}
+				if !callback(iter, field) {
+					return false
+				}
+				c = iter.nextToken()
+			}
+			if c != '}' {
+				iter.ReportError("ReadMapCB", `object not ended with }`)
+				return false
+			}
+			return true
+		}
+		if c == '}' {
+			return true
+		}
+		iter.ReportError("ReadMapCB", `expect " after }, but found `+string([]byte{c}))
+		return false
+	}
+	if c == 'n' {
+		iter.skipThreeBytes('u', 'l', 'l')
+		return true // null
+	}
+	iter.ReportError("ReadMapCB", `expect { or n, but found `+string([]byte{c}))
+	return false
+}
+
+func (iter *Iterator) readObjectStart() bool {
+	c := iter.nextToken()
+	if c == '{' {
+		c = iter.nextToken()
+		if c == '}' {
+			return false
+		}
+		iter.unreadByte()
+		return true
+	} else if c == 'n' {
+		iter.skipThreeBytes('u', 'l', 'l')
+		return false
+	}
+	iter.ReportError("readObjectStart", "expect { or n, but found "+string([]byte{c}))
+	return false
+}
+
+func (iter *Iterator) readObjectFieldAsBytes() (ret []byte) {
+	str := iter.ReadStringAsSlice()
+	if iter.skipWhitespacesWithoutLoadMore() {
+		if ret == nil {
+			ret = make([]byte, len(str))
+			copy(ret, str)
+		}
+		if !iter.loadMore() {
+			return
+		}
+	}
+	if iter.buf[iter.head] != ':' {
+		iter.ReportError("readObjectFieldAsBytes", "expect : after object field, but found "+string([]byte{iter.buf[iter.head]}))
+		return
+	}
+	iter.head++
+	if iter.skipWhitespacesWithoutLoadMore() {
+		if ret == nil {
+			ret = make([]byte, len(str))
+			copy(ret, str)
+		}
+		if !iter.loadMore() {
+			return
+		}
+	}
+	if ret == nil {
+		return str
+	}
+	return ret
+}

iter_skip.go

@@ -0,0 +1,129 @@
+package jsoniter
+
+import "fmt"
+
+// ReadNil reads a json object as nil and
+// returns whether it's a nil or not
+func (iter *Iterator) ReadNil() (ret bool) {
+	c := iter.nextToken()
+	if c == 'n' {
+		iter.skipThreeBytes('u', 'l', 'l') // null
+		return true
+	}
+	iter.unreadByte()
+	return false
+}
+
+// ReadBool reads a json object as BoolValue
+func (iter *Iterator) ReadBool() (ret bool) {
+	c := iter.nextToken()
+	if c == 't' {
+		iter.skipThreeBytes('r', 'u', 'e')
+		return true
+	}
+	if c == 'f' {
+		iter.skipFourBytes('a', 'l', 's', 'e')
+		return false
+	}
+	iter.ReportError("ReadBool", "expect t or f, but found "+string([]byte{c}))
+	return
+}
+
+// SkipAndReturnBytes skip next JSON element, and return its content as []byte.
+// The []byte can be kept, it is a copy of data.
+func (iter *Iterator) SkipAndReturnBytes() []byte {
+	iter.startCapture(iter.head)
+	iter.Skip()
+	return iter.stopCapture()
+}
+
+type captureBuffer struct {
+	startedAt int
+	captured  []byte
+}
+
+func (iter *Iterator) startCapture(captureStartedAt int) {
+	if iter.captured != nil {
+		panic("already in capture mode")
+	}
+	iter.captureStartedAt = captureStartedAt
+	iter.captured = make([]byte, 0, 32)
+}
+
+func (iter *Iterator) stopCapture() []byte {
+	if iter.captured == nil {
+		panic("not in capture mode")
+	}
+	captured := iter.captured
+	remaining := iter.buf[iter.captureStartedAt:iter.head]
+	iter.captureStartedAt = -1
+	iter.captured = nil
+	if len(captured) == 0 {
+		copied := make([]byte, len(remaining))
+		copy(copied, remaining)
+		return copied
+	}
+	captured = append(captured, remaining...)
+	return captured
+}
+
+// Skip skips a json object and positions to relatively the next json object
+func (iter *Iterator) Skip() {
+	c := iter.nextToken()
+	switch c {
+	case '"':
+		iter.skipString()
+	case 'n':
+		iter.skipThreeBytes('u', 'l', 'l') // null
+	case 't':
+		iter.skipThreeBytes('r', 'u', 'e') // true
+	case 'f':
+		iter.skipFourBytes('a', 'l', 's', 'e') // false
+	case '0':
+		iter.unreadByte()
+		iter.ReadFloat32()
+	case '-', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		iter.skipNumber()
+	case '[':
+		iter.skipArray()
+	case '{':
+		iter.skipObject()
+	default:
+		iter.ReportError("Skip", fmt.Sprintf("do not know how to skip: %v", c))
+		return
+	}
+}
+
+func (iter *Iterator) skipFourBytes(b1, b2, b3, b4 byte) {
+	if iter.readByte() != b1 {
+		iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+		return
+	}
+	if iter.readByte() != b2 {
+		iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+		return
+	}
+	if iter.readByte() != b3 {
+		iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+		return
+	}
+	if iter.readByte() != b4 {
+		iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+		return
+	}
+}
+
+func (iter *Iterator) skipThreeBytes(b1, b2, b3 byte) {
+	if iter.readByte() != b1 {
+		iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
+		return
+	}
+	if iter.readByte() != b2 {
+		iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
+		return
+	}
+	if iter.readByte() != b3 {
+		iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
+		return
+	}
+}

iter_skip_sloppy.go

@@ -1,88 +1,78 @@
+//+build jsoniter_sloppy
+
 package jsoniter
 
-import "fmt"
+// sloppy but faster implementation, do not validate the input json
 
-// ReadNil reads a json object as nil and
-// returns whether it's a nil or not
-func (iter *Iterator) ReadNil() (ret bool) {
-	c := iter.nextToken()
-	if c == 'n' {
-		iter.skipFixedBytes(3) // null
-		return true
-	}
-	iter.unreadByte()
-	return false
-}
-
-// ReadBool reads a json object as Bool
-func (iter *Iterator) ReadBool() (ret bool) {
-	c := iter.nextToken()
-	if c == 't' {
-		iter.skipFixedBytes(3)
-		return true
-	}
-	if c == 'f' {
-		iter.skipFixedBytes(4)
-		return false
-	}
-	iter.ReportError("ReadBool", "expect t or f")
-	return
-}
-
-func (iter *Iterator) SkipAndReturnBytes() []byte {
-	iter.startCapture(iter.head)
-	iter.Skip()
-	return iter.stopCapture()
-}
-
-type captureBuffer struct {
-	startedAt int
-	captured  []byte
-}
-
-func (iter *Iterator) startCapture(captureStartedAt int) {
-	if iter.captured != nil {
-		panic("already in capture mode")
-	}
-	iter.captureStartedAt = captureStartedAt
-	iter.captured = make([]byte, 0, 32)
-}
-
-func (iter *Iterator) stopCapture() []byte {
-	if iter.captured == nil {
-		panic("not in capture mode")
-	}
-	captured := iter.captured
-	remaining := iter.buf[iter.captureStartedAt:iter.head]
-	iter.captureStartedAt = -1
-	iter.captured = nil
-	if len(captured) == 0 {
-		return remaining
-	} else {
-		captured = append(captured, remaining...)
-		return captured
+func (iter *Iterator) skipNumber() {
+	for {
+		for i := iter.head; i < iter.tail; i++ {
+			c := iter.buf[i]
+			switch c {
+			case ' ', '\n', '\r', '\t', ',', '}', ']':
+				iter.head = i
+				return
+			}
+		}
+		if !iter.loadMore() {
+			return
+		}
 	}
 }
 
-// Skip skips a json object and positions to relatively the next json object
-func (iter *Iterator) Skip() {
-	c := iter.nextToken()
-	switch c {
-	case '"':
-		iter.skipString()
-	case 'n', 't':
-		iter.skipFixedBytes(3) // null or true
-	case 'f':
-		iter.skipFixedBytes(4) // false
-	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-		iter.skipNumber()
-	case '[':
-		iter.skipArray()
-	case '{':
-		iter.skipObject()
-	default:
-		iter.ReportError("Skip", fmt.Sprintf("do not know how to skip: %v", c))
-		return
+func (iter *Iterator) skipArray() {
+	level := 1
+	for {
+		for i := iter.head; i < iter.tail; i++ {
+			switch iter.buf[i] {
+			case '"': // If inside string, skip it
+				iter.head = i + 1
+				iter.skipString()
+				i = iter.head - 1 // it will be i++ soon
+			case '[': // If open symbol, increase level
+				level++
+			case ']': // If close symbol, increase level
+				level--
+
+				// If we have returned to the original level, we're done
+				if level == 0 {
+					iter.head = i + 1
+					return
+				}
+			}
+		}
+		if !iter.loadMore() {
+			iter.ReportError("skipObject", "incomplete array")
+			return
+		}
+	}
+}
+
+func (iter *Iterator) skipObject() {
+	level := 1
+	for {
+		for i := iter.head; i < iter.tail; i++ {
+			switch iter.buf[i] {
+			case '"': // If inside string, skip it
+				iter.head = i + 1
+				iter.skipString()
+				i = iter.head - 1 // it will be i++ soon
+			case '{': // If open symbol, increase level
+				level++
+			case '}': // If close symbol, increase level
+				level--
+
+				// If we have returned to the original level, we're done
+				if level == 0 {
+					iter.head = i + 1
+					return
+				}
+			}
+		}
+		if !iter.loadMore() {
+			iter.ReportError("skipObject", "incomplete object")
+			return
+		}
 	}
 }
 
@@ -152,89 +142,3 @@ func (iter *Iterator) findStringEnd() (int, bool) {
 	}
 	return -1, true // end with \
 }
-
-func (iter *Iterator) skipArray() {
-	level := 1
-	for {
-		for i := iter.head; i < iter.tail; i++ {
-			switch iter.buf[i] {
-			case '"': // If inside string, skip it
-				iter.head = i + 1
-				iter.skipString()
-				i = iter.head - 1 // it will be i++ soon
-			case '[': // If open symbol, increase level
-				level++
-			case ']': // If close symbol, increase level
-				level--
-
-				// If we have returned to the original level, we're done
-				if level == 0 {
-					iter.head = i + 1
-					return
-				}
-			}
-		}
-		if !iter.loadMore() {
-			iter.ReportError("skipObject", "incomplete array")
-			return
-		}
-	}
-}
-
-func (iter *Iterator) skipObject() {
-	level := 1
-	for {
-		for i := iter.head; i < iter.tail; i++ {
-			switch iter.buf[i] {
-			case '"': // If inside string, skip it
-				iter.head = i + 1
-				iter.skipString()
-				i = iter.head - 1 // it will be i++ soon
-			case '{': // If open symbol, increase level
-				level++
-			case '}': // If close symbol, increase level
-				level--
-
-				// If we have returned to the original level, we're done
-				if level == 0 {
-					iter.head = i + 1
-					return
-				}
-			}
-		}
-		if !iter.loadMore() {
-			iter.ReportError("skipObject", "incomplete object")
-			return
-		}
-	}
-}
-
-func (iter *Iterator) skipNumber() {
-	for {
-		for i := iter.head; i < iter.tail; i++ {
-			c := iter.buf[i]
-			switch c {
-			case ' ', '\n', '\r', '\t', ',', '}', ']':
-				iter.head = i
-				return
-			}
-		}
-		if !iter.loadMore() {
-			return
-		}
-	}
-}
-
-func (iter *Iterator) skipFixedBytes(n int) {
-	iter.head += n
-	if iter.head >= iter.tail {
-		more := iter.head - iter.tail
-		if !iter.loadMore() {
-			if more > 0 {
-				iter.ReportError("skipFixedBytes", "unexpected end")
-			}
-			return
-		}
-		iter.head += more
-	}
-}

iter_skip_sloppy_test.go

@@ -1,7 +1,9 @@
+//+build jsoniter_sloppy
+
 package jsoniter
 
 import (
-	"github.com/json-iterator/go/require"
+	"github.com/stretchr/testify/require"
 	"io"
 	"testing"
 )

iter_skip_strict.go

@@ -0,0 +1,89 @@
+//+build !jsoniter_sloppy
+
+package jsoniter
+
+import "fmt"
+
+func (iter *Iterator) skipNumber() {
+	if !iter.trySkipNumber() {
+		iter.unreadByte()
+		iter.ReadFloat32()
+	}
+}
+
+func (iter *Iterator) trySkipNumber() bool {
+	dotFound := false
+	for i := iter.head; i < iter.tail; i++ {
+		c := iter.buf[i]
+		switch c {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		case '.':
+			if dotFound {
+				iter.ReportError("validateNumber", `more than one dot found in number`)
+				return true // already failed
+			}
+			if i+1 == iter.tail {
+				return false
+			}
+			c = iter.buf[i+1]
+			switch c {
+			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			default:
+				iter.ReportError("validateNumber", `missing digit after dot`)
+				return true // already failed
+			}
+			dotFound = true
+		default:
+			switch c {
+			case ',', ']', '}', ' ', '\t', '\n', '\r':
+				if iter.head == i {
+					return false // if - without following digits
+				}
+				iter.head = i
+				return true // must be valid
+			}
+			return false // may be invalid
+		}
+	}
+	return false
+}
+
+func (iter *Iterator) skipString() {
+	if !iter.trySkipString() {
+		iter.unreadByte()
+		iter.ReadString()
+	}
+}
+
+func (iter *Iterator) trySkipString() bool {
+	for i := iter.head; i < iter.tail; i++ {
+		c := iter.buf[i]
+		if c == '"' {
+			iter.head = i + 1
+			return true // valid
+		} else if c == '\\' {
+			return false
+		} else if c < ' ' {
+			iter.ReportError("trySkipString",
+				fmt.Sprintf(`invalid control character found: %d`, c))
+			return true // already failed
+		}
+	}
+	return false
+}
+
+func (iter *Iterator) skipObject() {
+	iter.unreadByte()
+	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
+		iter.Skip()
+		return true
+	})
+}
+
+func (iter *Iterator) skipArray() {
+	iter.unreadByte()
+	iter.ReadArrayCB(func(iter *Iterator) bool {
+		iter.Skip()
+		return true
+	})
+}

iter_str.go

@@ -1,9 +1,11 @@
 package jsoniter
 
 import (
+	"fmt"
 	"unicode/utf16"
 )
 
+// ReadString read string from iterator
 func (iter *Iterator) ReadString() (ret string) {
 	c := iter.nextToken()
 	if c == '"' {
@@ -15,14 +17,18 @@ func (iter *Iterator) ReadString() (ret string) {
 				return ret
 			} else if c == '\\' {
 				break
+			} else if c < ' ' {
+				iter.ReportError("ReadString",
+					fmt.Sprintf(`invalid control character found: %d`, c))
+				return
 			}
 		}
 		return iter.readStringSlowPath()
 	} else if c == 'n' {
-		iter.skipFixedBytes(3)
+		iter.skipThreeBytes('u', 'l', 'l')
 		return ""
 	}
-	iter.ReportError("ReadString", `expects " or n`)
+	iter.ReportError("ReadString", `expects " or n, but found `+string([]byte{c}))
 	return
 }
 
@@ -36,66 +42,77 @@ func (iter *Iterator) readStringSlowPath() (ret string) {
 		}
 		if c == '\\' {
 			c = iter.readByte()
-			switch c {
-			case 'u', 'U':
-				r := iter.readU4()
-				if utf16.IsSurrogate(r) {
-					c = iter.readByte()
-					if iter.Error != nil {
-						return
-					}
-					if c != '\\' {
-						iter.ReportError("ReadString",
-							`expects \u after utf16 surrogate, but \ not found`)
-						return
-					}
-					c = iter.readByte()
-					if iter.Error != nil {
-						return
-					}
-					if c != 'u' && c != 'U' {
-						iter.ReportError("ReadString",
-							`expects \u after utf16 surrogate, but \u not found`)
-						return
-					}
-					r2 := iter.readU4()
-					if iter.Error != nil {
-						return
-					}
-					combined := utf16.DecodeRune(r, r2)
-					str = appendRune(str, combined)
-				} else {
-					str = appendRune(str, r)
-				}
-			case '"':
-				str = append(str, '"')
-			case '\\':
-				str = append(str, '\\')
-			case '/':
-				str = append(str, '/')
-			case 'b':
-				str = append(str, '\b')
-			case 'f':
-				str = append(str, '\f')
-			case 'n':
-				str = append(str, '\n')
-			case 'r':
-				str = append(str, '\r')
-			case 't':
-				str = append(str, '\t')
-			default:
-				iter.ReportError("ReadString",
-					`invalid escape char after \`)
-				return
-			}
+			str = iter.readEscapedChar(c, str)
 		} else {
 			str = append(str, c)
 		}
 	}
-	iter.ReportError("ReadString", "unexpected end of input")
+	iter.ReportError("readStringSlowPath", "unexpected end of input")
 	return
 }
 
+func (iter *Iterator) readEscapedChar(c byte, str []byte) []byte {
+	switch c {
+	case 'u':
+		r := iter.readU4()
+		if utf16.IsSurrogate(r) {
+			c = iter.readByte()
+			if iter.Error != nil {
+				return nil
+			}
+			if c != '\\' {
+				iter.unreadByte()
+				str = appendRune(str, r)
+				return str
+			}
+			c = iter.readByte()
+			if iter.Error != nil {
+				return nil
+			}
+			if c != 'u' {
+				str = appendRune(str, r)
+				return iter.readEscapedChar(c, str)
+			}
+			r2 := iter.readU4()
+			if iter.Error != nil {
+				return nil
+			}
+			combined := utf16.DecodeRune(r, r2)
+			if combined == '\uFFFD' {
+				str = appendRune(str, r)
+				str = appendRune(str, r2)
+			} else {
+				str = appendRune(str, combined)
+			}
+		} else {
+			str = appendRune(str, r)
+		}
+	case '"':
+		str = append(str, '"')
+	case '\\':
+		str = append(str, '\\')
+	case '/':
+		str = append(str, '/')
+	case 'b':
+		str = append(str, '\b')
+	case 'f':
+		str = append(str, '\f')
+	case 'n':
+		str = append(str, '\n')
+	case 'r':
+		str = append(str, '\r')
+	case 't':
+		str = append(str, '\t')
+	default:
+		iter.ReportError("readEscapedChar",
+			`invalid escape char after \`)
+		return nil
+	}
+	return str
+}
+
+// ReadStringAsSlice read string from iterator without copying into string form.
+// The []byte can not be kept, as it will change after next iterator call.
 func (iter *Iterator) ReadStringAsSlice() (ret []byte) {
 	c := iter.nextToken()
 	if c == '"' {
@@ -122,7 +139,7 @@ func (iter *Iterator) ReadStringAsSlice() (ret []byte) {
 		}
 		return copied
 	}
-	iter.ReportError("ReadString", `expects " or n`)
+	iter.ReportError("ReadStringAsSlice", `expects " or n, but found `+string([]byte{c}))
 	return
 }
 
@@ -139,7 +156,7 @@ func (iter *Iterator) readU4() (ret rune) {
 		} else if c >= 'A' && c <= 'F' {
 			ret = ret*16 + rune(c-'A'+10)
 		} else {
-			iter.ReportError("readU4", "expects 0~9 or a~f")
+			iter.ReportError("readU4", "expects 0~9 or a~f, but found "+string([]byte{c}))
 			return
 		}
 	}

jsoniter.go

@@ -0,0 +1,18 @@
+// Package jsoniter implements encoding and decoding of JSON as defined in
+// RFC 4627 and provides interfaces with identical syntax of standard lib encoding/json.
+// Converting from encoding/json to jsoniter is no more than replacing the package with jsoniter
+// and variable type declarations (if any).
+// jsoniter interfaces gives 100% compatibility with code using standard lib.
+//
+// "JSON and Go"
+// (https://golang.org/doc/articles/json_and_go.html)
+// gives a description of how Marshal/Unmarshal operate
+// between arbitrary or predefined json objects and bytes,
+// and it applies to jsoniter.Marshal/Unmarshal as well.
+//
+// Besides, jsoniter.Iterator provides a different set of interfaces
+// iterating given bytes/string/reader
+// and yielding parsed elements one by one.
+// This set of interfaces reads input as required and gives
+// better performance.
+package jsoniter

jsoniter_any_array_test.go

@@ -1,96 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_read_empty_array_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("[]"))
-	should.Equal(Array, any.Get().ValueType())
-	should.Equal(Invalid, any.Get(0.3).ValueType())
-	should.Equal(0, any.Size())
-	should.Equal(Array, any.ValueType())
-	should.Nil(any.LastError())
-	should.Equal(0, any.ToInt())
-	should.Equal(int32(0), any.ToInt32())
-	should.Equal(int64(0), any.ToInt64())
-	should.Equal(uint(0), any.ToUint())
-	should.Equal(uint32(0), any.ToUint32())
-	should.Equal(uint64(0), any.ToUint64())
-	should.Equal(float32(0), any.ToFloat32())
-	should.Equal(float64(0), any.ToFloat64())
-}
-
-func Test_read_one_element_array_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("[1]"))
-	should.Equal(1, any.Size())
-}
-
-func Test_read_two_element_array_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("[1,2]"))
-	should.Equal(1, any.Get(0).ToInt())
-	should.Equal(2, any.Size())
-	should.True(any.ToBool())
-	should.Equal(1, any.ToInt())
-	should.Equal(1, any.GetArray()[0].ToInt())
-	should.Equal([]interface{}{float64(1), float64(2)}, any.GetInterface())
-	stream := NewStream(ConfigDefault, nil, 32)
-	any.WriteTo(stream)
-	should.Equal("[1,2]", string(stream.Buffer()))
-	arr := []int{}
-	any.ToVal(&arr)
-	should.Equal([]int{1, 2}, arr)
-}
-
-func Test_wrap_array(t *testing.T) {
-	should := require.New(t)
-	any := Wrap([]int{1, 2, 3})
-	should.Equal("[1,2,3]", any.ToString())
-}
-
-func Test_array_lazy_any_get(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("[1,[2,3],4]"))
-	should.Equal(3, any.Get(1, 1).ToInt())
-	should.Equal("[1,[2,3],4]", any.ToString())
-}
-
-func Test_array_lazy_any_get_all(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("[[1],[2],[3,4]]"))
-	should.Equal("[1,2,3]", any.Get('*', 0).ToString())
-	any = Get([]byte("[[[1],[2],[3,4]]]"), 0, '*', 0)
-	should.Equal("[1,2,3]", any.ToString())
-}
-
-func Test_array_wrapper_any_get_all(t *testing.T) {
-	should := require.New(t)
-	any := wrapArray([][]int{
-		{1, 2},
-		{3, 4},
-		{5, 6},
-	})
-	should.Equal("[1,3,5]", any.Get('*', 0).ToString())
-	should.Equal(Array, any.ValueType())
-	should.True(any.ToBool())
-	should.Equal(1, any.Get(0, 0).ToInt())
-}
-
-func Test_array_lazy_any_get_invalid(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("[]"))
-	should.Equal(Invalid, any.Get(1, 1).ValueType())
-	should.NotNil(any.Get(1, 1).LastError())
-	should.Equal(Invalid, any.Get("1").ValueType())
-	should.NotNil(any.Get("1").LastError())
-}
-
-func Test_invalid_array(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("["), 0)
-	should.Equal(Invalid, any.ValueType())
-}

jsoniter_any_bool_test.go

@@ -1,12 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_read_bool_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("true"))
-	should.True(any.ToBool())
-}

jsoniter_any_float_test.go

@@ -1,14 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_read_float_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("12.3"))
-	should.Equal(float64(12.3), any.ToFloat64())
-	should.Equal("12.3", any.ToString())
-	should.True(any.ToBool())
-}

jsoniter_any_int_test.go

@@ -1,22 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"io"
-	"testing"
-)
-
-func Test_read_int64_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("1234"))
-	should.Equal(1234, any.ToInt())
-	should.Equal(io.EOF, any.LastError())
-	should.Equal("1234", any.ToString())
-	should.True(any.ToBool())
-}
-
-func Test_int_lazy_any_get(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte("1234"))
-	should.Equal(Invalid, any.Get(1, "2").ValueType())
-}

jsoniter_any_map_test.go

@@ -1,14 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_wrap_map(t *testing.T) {
-	should := require.New(t)
-	any := Wrap(map[string]string{"Field1": "hello"})
-	should.Equal("hello", any.Get("Field1").ToString())
-	any = Wrap(map[string]string{"Field1": "hello"})
-	should.Equal(1, any.Size())
-}

jsoniter_any_object_test.go

@@ -1,75 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_read_object_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte(`{"a":"b","c":"d"}`))
-	should.Equal(`{"a":"b","c":"d"}`, any.ToString())
-	// partial parse
-	should.Equal("b", any.Get("a").ToString())
-	should.Equal("d", any.Get("c").ToString())
-	should.Equal(2, len(any.Keys()))
-	any = Get([]byte(`{"a":"b","c":"d"}`))
-	// full parse
-	should.Equal(2, len(any.Keys()))
-	should.Equal(2, any.Size())
-	should.True(any.ToBool())
-	should.Equal(1, any.ToInt())
-	should.Equal(Object, any.ValueType())
-	should.Nil(any.LastError())
-	should.Equal("b", any.GetObject()["a"].ToString())
-	obj := struct {
-		A string
-	}{}
-	any.ToVal(&obj)
-	should.Equal("b", obj.A)
-}
-
-func Test_object_lazy_any_get(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte(`{"a":{"b":{"c":"d"}}}`))
-	should.Equal("d", any.Get("a", "b", "c").ToString())
-}
-
-func Test_object_lazy_any_get_all(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte(`{"a":[0],"b":[1]}`))
-	should.Contains(any.Get('*', 0).ToString(), `"a":0`)
-}
-
-func Test_object_lazy_any_get_invalid(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte(`{}`))
-	should.Equal(Invalid, any.Get("a", "b", "c").ValueType())
-	should.Equal(Invalid, any.Get(1).ValueType())
-}
-
-func Test_wrap_object(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		field2 string
-	}
-	any := Wrap(TestObject{"hello", "world"})
-	should.Equal("hello", any.Get("Field1").ToString())
-	any = Wrap(TestObject{"hello", "world"})
-	should.Equal(2, any.Size())
-	should.Equal(`{"Field1":"hello"}`, any.Get('*').ToString())
-}
-
-func Test_any_within_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 Any
-		Field2 Any
-	}
-	obj := TestObject{}
-	err := UnmarshalFromString(`{"Field1": "hello", "Field2": [1,2,3]}`, &obj)
-	should.Nil(err)
-	should.Equal("hello", obj.Field1.ToString())
-	should.Equal("[1,2,3]", obj.Field2.ToString())
-}

jsoniter_any_string_test.go

@@ -1,25 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_read_string_as_any(t *testing.T) {
-	should := require.New(t)
-	any := Get([]byte(`"hello"`))
-	should.Equal("hello", any.ToString())
-	should.True(any.ToBool())
-	any = Get([]byte(`" "`))
-	should.False(any.ToBool())
-	any = Get([]byte(`"false"`))
-	should.False(any.ToBool())
-	any = Get([]byte(`"123"`))
-	should.Equal(123, any.ToInt())
-}
-
-func Test_wrap_string(t *testing.T) {
-	should := require.New(t)
-	any := WrapString("123")
-	should.Equal(123, any.ToInt())
-}

jsoniter_bool_test.go

@@ -1,80 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_true(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `true`)
-	should.True(iter.ReadBool())
-	iter = ParseString(ConfigDefault, `true`)
-	should.Equal(true, iter.Read())
-}
-
-func Test_false(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `false`)
-	should.False(iter.ReadBool())
-}
-
-func Test_write_true_false(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigDefault, buf, 4096)
-	stream.WriteTrue()
-	stream.WriteFalse()
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal("truefalse", buf.String())
-}
-
-func Test_write_val_bool(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigDefault, buf, 4096)
-	stream.WriteVal(true)
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal("true", buf.String())
-}
-
-func Test_encode_string_bool(t *testing.T) {
-	type TestObject struct {
-		Field bool `json:",omitempty,string"`
-	}
-	should := require.New(t)
-	output, err := json.Marshal(TestObject{true})
-	should.Nil(err)
-	should.Equal(`{"Field":"true"}`, string(output))
-	output, err = Marshal(TestObject{true})
-	should.Nil(err)
-	should.Equal(`{"Field":"true"}`, string(output))
-}
-
-func Test_decode_string_bool(t *testing.T) {
-	type TestObject struct {
-		Field bool `json:",omitempty,string"`
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	err := json.Unmarshal([]byte(`{"Field":"true"}`), &obj)
-	should.Nil(err)
-	should.True(obj.Field)
-
-	obj = TestObject{}
-	err = json.Unmarshal([]byte(`{"Field":true}`), &obj)
-	should.NotNil(err)
-
-	obj = TestObject{}
-	err = Unmarshal([]byte(`{"Field":"true"}`), &obj)
-	should.Nil(err)
-	should.True(obj.Field)
-
-	obj = TestObject{}
-	err = Unmarshal([]byte(`{"Field":true}`), &obj)
-	should.NotNil(err)
-}

jsoniter_customize_test.go

@@ -1,244 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"strconv"
-	"testing"
-	"time"
-	"unsafe"
-)
-
-func Test_customize_type_decoder(t *testing.T) {
-	RegisterTypeDecoderFunc("time.Time", func(ptr unsafe.Pointer, iter *Iterator) {
-		t, err := time.ParseInLocation("2006-01-02 15:04:05", iter.ReadString(), time.UTC)
-		if err != nil {
-			iter.Error = err
-			return
-		}
-		*((*time.Time)(ptr)) = t
-	})
-	defer ConfigDefault.cleanDecoders()
-	val := time.Time{}
-	err := Unmarshal([]byte(`"2016-12-05 08:43:28"`), &val)
-	if err != nil {
-		t.Fatal(err)
-	}
-	year, month, day := val.Date()
-	if year != 2016 || month != 12 || day != 5 {
-		t.Fatal(val)
-	}
-}
-
-func Test_customize_type_encoder(t *testing.T) {
-	should := require.New(t)
-	RegisterTypeEncoderFunc("time.Time", func(ptr unsafe.Pointer, stream *Stream) {
-		t := *((*time.Time)(ptr))
-		stream.WriteString(t.UTC().Format("2006-01-02 15:04:05"))
-	}, nil)
-	defer ConfigDefault.cleanEncoders()
-	val := time.Unix(0, 0)
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`"1970-01-01 00:00:00"`, str)
-}
-
-func Test_customize_byte_array_encoder(t *testing.T) {
-	ConfigDefault.cleanEncoders()
-	should := require.New(t)
-	RegisterTypeEncoderFunc("[]uint8", func(ptr unsafe.Pointer, stream *Stream) {
-		t := *((*[]byte)(ptr))
-		stream.WriteString(string(t))
-	}, nil)
-	defer ConfigDefault.cleanEncoders()
-	val := []byte("abc")
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`"abc"`, str)
-}
-
-func Test_customize_float_marshal(t *testing.T) {
-	should := require.New(t)
-	json := Config{MarshalFloatWith6Digits: true}.Froze()
-	str, err := json.MarshalToString(float32(1.23456789))
-	should.Nil(err)
-	should.Equal("1.234568", str)
-}
-
-type Tom struct {
-	field1 string
-}
-
-func Test_customize_field_decoder(t *testing.T) {
-	RegisterFieldDecoderFunc("jsoniter.Tom", "field1", func(ptr unsafe.Pointer, iter *Iterator) {
-		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
-	})
-	defer ConfigDefault.cleanDecoders()
-	tom := Tom{}
-	err := Unmarshal([]byte(`{"field1": 100}`), &tom)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-type TestObject1 struct {
-	field1 string
-}
-
-type testExtension struct {
-	DummyExtension
-}
-
-func (extension *testExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
-	if structDescriptor.Type.String() != "jsoniter.TestObject1" {
-		return
-	}
-	binding := structDescriptor.GetField("field1")
-	binding.Encoder = &funcEncoder{fun: func(ptr unsafe.Pointer, stream *Stream) {
-		str := *((*string)(ptr))
-		val, _ := strconv.Atoi(str)
-		stream.WriteInt(val)
-	}}
-	binding.Decoder = &funcDecoder{func(ptr unsafe.Pointer, iter *Iterator) {
-		*((*string)(ptr)) = strconv.Itoa(iter.ReadInt())
-	}}
-	binding.ToNames = []string{"field-1"}
-	binding.FromNames = []string{"field-1"}
-}
-
-func Test_customize_field_by_extension(t *testing.T) {
-	should := require.New(t)
-	RegisterExtension(&testExtension{})
-	obj := TestObject1{}
-	err := UnmarshalFromString(`{"field-1": 100}`, &obj)
-	should.Nil(err)
-	should.Equal("100", obj.field1)
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"field-1":100}`, str)
-}
-
-//func Test_unexported_fields(t *testing.T) {
-//	jsoniter := Config{SupportUnexportedStructFields: true}.Froze()
-//	should := require.New(t)
-//	type TestObject struct {
-//		field1 string
-//		field2 string `json:"field-2"`
-//	}
-//	obj := TestObject{}
-//	obj.field1 = "hello"
-//	should.Nil(jsoniter.UnmarshalFromString(`{}`, &obj))
-//	should.Equal("hello", obj.field1)
-//	should.Nil(jsoniter.UnmarshalFromString(`{"field1": "world", "field-2": "abc"}`, &obj))
-//	should.Equal("world", obj.field1)
-//	should.Equal("abc", obj.field2)
-//	str, err := jsoniter.MarshalToString(obj)
-//	should.Nil(err)
-//	should.Contains(str, `"field-2":"abc"`)
-//}
-
-type timeImplementedMarshaler time.Time
-
-func (obj timeImplementedMarshaler) MarshalJSON() ([]byte, error) {
-	seconds := time.Time(obj).Unix()
-	return []byte(strconv.FormatInt(seconds, 10)), nil
-}
-
-func Test_marshaler(t *testing.T) {
-	type TestObject struct {
-		Field timeImplementedMarshaler
-	}
-	should := require.New(t)
-	val := timeImplementedMarshaler(time.Unix(123, 0))
-	obj := TestObject{val}
-	bytes, err := json.Marshal(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":123}`, string(bytes))
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":123}`, str)
-}
-
-func Test_marshaler_and_encoder(t *testing.T) {
-	type TestObject struct {
-		Field *timeImplementedMarshaler
-	}
-	ConfigDefault.cleanEncoders()
-	should := require.New(t)
-	RegisterTypeEncoderFunc("jsoniter.timeImplementedMarshaler", func(ptr unsafe.Pointer, stream *Stream) {
-		stream.WriteString("hello from encoder")
-	}, nil)
-	val := timeImplementedMarshaler(time.Unix(123, 0))
-	obj := TestObject{&val}
-	bytes, err := json.Marshal(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":123}`, string(bytes))
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":"hello from encoder"}`, str)
-}
-
-type ObjectImplementedUnmarshaler int
-
-func (obj *ObjectImplementedUnmarshaler) UnmarshalJSON([]byte) error {
-	*obj = 100
-	return nil
-}
-
-func Test_unmarshaler(t *testing.T) {
-	type TestObject struct {
-		Field  *ObjectImplementedUnmarshaler
-		Field2 string
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	val := ObjectImplementedUnmarshaler(0)
-	obj.Field = &val
-	err := json.Unmarshal([]byte(`{"Field":"hello"}`), &obj)
-	should.Nil(err)
-	should.Equal(100, int(*obj.Field))
-	err = Unmarshal([]byte(`{"Field":"hello"}`), &obj)
-	should.Nil(err)
-	should.Equal(100, int(*obj.Field))
-}
-
-func Test_unmarshaler_and_decoder(t *testing.T) {
-	type TestObject struct {
-		Field  *ObjectImplementedUnmarshaler
-		Field2 string
-	}
-	ConfigDefault.cleanDecoders()
-	should := require.New(t)
-	RegisterTypeDecoderFunc("jsoniter.ObjectImplementedUnmarshaler", func(ptr unsafe.Pointer, iter *Iterator) {
-		*(*ObjectImplementedUnmarshaler)(ptr) = 10
-		iter.Skip()
-	})
-	obj := TestObject{}
-	val := ObjectImplementedUnmarshaler(0)
-	obj.Field = &val
-	err := json.Unmarshal([]byte(`{"Field":"hello"}`), &obj)
-	should.Nil(err)
-	should.Equal(100, int(*obj.Field))
-	err = Unmarshal([]byte(`{"Field":"hello"}`), &obj)
-	should.Nil(err)
-	should.Equal(10, int(*obj.Field))
-}
-
-type tmString string
-type tmStruct struct {
-	String tmString
-}
-
-func (s tmStruct) MarshalJSON() ([]byte, error) {
-	var b []byte
-	b = append(b, '"')
-	b = append(b, s.String...)
-	b = append(b, '"')
-	return b, nil
-}
-
-func Test_marshaler_on_struct(t *testing.T) {
-	fixed := tmStruct{"hello"}
-	//json.Marshal(fixed)
-	Marshal(fixed)
-}

jsoniter_demo_test.go

@@ -1,86 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_bind_api_demo(t *testing.T) {
-	should := require.New(t)
-	val := []int{}
-	err := UnmarshalFromString(`[0,1,2,3]  `, &val)
-	should.Nil(err)
-	should.Equal([]int{0, 1, 2, 3}, val)
-}
-
-func Test_iterator_api_demo(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[0,1,2,3]`)
-	total := 0
-	for iter.ReadArray() {
-		total += iter.ReadInt()
-	}
-	fmt.Println(total)
-}
-
-type People struct {
-	Name    string
-	Gender  string
-	Age     int
-	Address string
-	Mobile  string
-	Country string
-	Height  int
-}
-
-func jsoniterMarshal(p *People) error {
-	_, err := Marshal(p)
-	if nil != err {
-		return err
-	}
-	return nil
-}
-func stdMarshal(p *People) error {
-	_, err := json.Marshal(p)
-	if nil != err {
-		return err
-	}
-	return nil
-}
-
-func BenchmarkJosniterMarshal(b *testing.B) {
-	var p People
-	p.Address = "上海市徐汇区漕宝路"
-	p.Age = 30
-	p.Country = "中国"
-	p.Gender = "male"
-	p.Height = 170
-	p.Mobile = "18502120533"
-	p.Name = "Elvin"
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		err := jsoniterMarshal(&p)
-		if nil != err {
-			b.Error(err)
-		}
-	}
-}
-
-func BenchmarkStdMarshal(b *testing.B) {
-	var p People
-	p.Address = "上海市徐汇区漕宝路"
-	p.Age = 30
-	p.Country = "中国"
-	p.Gender = "male"
-	p.Height = 170
-	p.Mobile = "18502120533"
-	p.Name = "Elvin"
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		err := stdMarshal(&p)
-		if nil != err {
-			b.Error(err)
-		}
-	}
-}

jsoniter_fixed_array_test.go

@@ -1,37 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_encode_fixed_array(t *testing.T) {
-	should := require.New(t)
-	type FixedArray [2]float64
-	fixed := FixedArray{0.1, 1.0}
-	output, err := MarshalToString(fixed)
-	should.Nil(err)
-	should.Equal("[0.1,1]", output)
-}
-
-func Test_encode_fixed_array_of_map(t *testing.T) {
-	should := require.New(t)
-	type FixedArray [2]map[string]string
-	fixed := FixedArray{map[string]string{"1": "2"}, map[string]string{"3": "4"}}
-	output, err := MarshalToString(fixed)
-	should.Nil(err)
-	should.Equal(`[{"1":"2"},{"3":"4"}]`, output)
-}
-
-func Test_decode_fixed_array(t *testing.T) {
-	should := require.New(t)
-	type FixedArray [2]float64
-	var fixed FixedArray
-	should.Nil(json.Unmarshal([]byte("[1,2,3]"), &fixed))
-	should.Equal(float64(1), fixed[0])
-	should.Equal(float64(2), fixed[1])
-	should.Nil(Unmarshal([]byte("[1,2,3]"), &fixed))
-	should.Equal(float64(1), fixed[0])
-	should.Equal(float64(2), fixed[1])
-}

jsoniter_float_test.go

@@ -1,191 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"github.com/json-iterator/go/require"
-	"strconv"
-	"testing"
-)
-
-func Test_read_big_float(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `12.3`)
-	val := iter.ReadBigFloat()
-	val64, _ := val.Float64()
-	should.Equal(12.3, val64)
-}
-
-func Test_read_big_int(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `92233720368547758079223372036854775807`)
-	val := iter.ReadBigInt()
-	should.NotNil(val)
-	should.Equal(`92233720368547758079223372036854775807`, val.String())
-}
-
-func Test_read_float(t *testing.T) {
-	inputs := []string{`1.1`, `1000`, `9223372036854775807`, `12.3`, `-12.3`, `720368.54775807`, `720368.547758075`}
-	for _, input := range inputs {
-		// non-streaming
-		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input+",")
-			expected, err := strconv.ParseFloat(input, 32)
-			should.Nil(err)
-			should.Equal(float32(expected), iter.ReadFloat32())
-		})
-		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input+",")
-			expected, err := strconv.ParseFloat(input, 64)
-			should.Nil(err)
-			should.Equal(expected, iter.ReadFloat64())
-		})
-		// streaming
-		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input+","), 2)
-			expected, err := strconv.ParseFloat(input, 32)
-			should.Nil(err)
-			should.Equal(float32(expected), iter.ReadFloat32())
-		})
-		t.Run(fmt.Sprintf("%v", input), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input+","), 2)
-			expected, err := strconv.ParseFloat(input, 64)
-			should.Nil(err)
-			should.Equal(expected, iter.ReadFloat64())
-		})
-	}
-}
-
-func Test_read_float_as_interface(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `12.3`)
-	should.Equal(float64(12.3), iter.Read())
-}
-
-func Test_wrap_float(t *testing.T) {
-	should := require.New(t)
-	str, err := MarshalToString(WrapFloat64(12.3))
-	should.Nil(err)
-	should.Equal("12.3", str)
-}
-
-func Test_write_float32(t *testing.T) {
-	vals := []float32{0, 1, -1, 99, 0xff, 0xfff, 0xffff, 0xfffff, 0xffffff, 0x4ffffff, 0xfffffff,
-		-0x4ffffff, -0xfffffff, 1.2345, 1.23456, 1.234567, 1.001}
-	for _, val := range vals {
-		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
-			should := require.New(t)
-			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigDefault, buf, 4096)
-			stream.WriteFloat32Lossy(val)
-			stream.Flush()
-			should.Nil(stream.Error)
-			should.Equal(strconv.FormatFloat(float64(val), 'f', -1, 32), buf.String())
-		})
-		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
-			should := require.New(t)
-			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigDefault, buf, 4096)
-			stream.WriteVal(val)
-			stream.Flush()
-			should.Nil(stream.Error)
-			should.Equal(strconv.FormatFloat(float64(val), 'f', -1, 32), buf.String())
-		})
-	}
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigDefault, buf, 10)
-	stream.WriteRaw("abcdefg")
-	stream.WriteFloat32Lossy(1.123456)
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal("abcdefg1.123456", buf.String())
-}
-
-func Test_write_float64(t *testing.T) {
-	vals := []float64{0, 1, -1, 99, 0xff, 0xfff, 0xffff, 0xfffff, 0xffffff, 0x4ffffff, 0xfffffff,
-		-0x4ffffff, -0xfffffff, 1.2345, 1.23456, 1.234567, 1.001}
-	for _, val := range vals {
-		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
-			should := require.New(t)
-			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigDefault, buf, 4096)
-			stream.WriteFloat64Lossy(val)
-			stream.Flush()
-			should.Nil(stream.Error)
-			should.Equal(strconv.FormatFloat(val, 'f', -1, 64), buf.String())
-		})
-		t.Run(fmt.Sprintf("%v", val), func(t *testing.T) {
-			should := require.New(t)
-			buf := &bytes.Buffer{}
-			stream := NewStream(ConfigDefault, buf, 4096)
-			stream.WriteVal(val)
-			stream.Flush()
-			should.Nil(stream.Error)
-			should.Equal(strconv.FormatFloat(val, 'f', -1, 64), buf.String())
-		})
-	}
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigDefault, buf, 10)
-	stream.WriteRaw("abcdefg")
-	stream.WriteFloat64Lossy(1.123456)
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal("abcdefg1.123456", buf.String())
-}
-
-func Test_read_float64_cursor(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, "[1.23456789\n,2,3]")
-	should.True(iter.ReadArray())
-	should.Equal(1.23456789, iter.Read())
-	should.True(iter.ReadArray())
-	should.Equal(float64(2), iter.Read())
-}
-
-func Test_read_float_scientific(t *testing.T) {
-	should := require.New(t)
-	var obj interface{}
-	should.Nil(UnmarshalFromString(`1e1`, &obj))
-	should.Equal(float64(10), obj)
-	should.Nil(json.Unmarshal([]byte(`1e1`), &obj))
-	should.Equal(float64(10), obj)
-	should.Nil(UnmarshalFromString(`1.0e1`, &obj))
-	should.Equal(float64(10), obj)
-	should.Nil(json.Unmarshal([]byte(`1.0e1`), &obj))
-	should.Equal(float64(10), obj)
-}
-
-func Test_lossy_float_marshal(t *testing.T) {
-	should := require.New(t)
-	api := Config{MarshalFloatWith6Digits: true}.Froze()
-	output, err := api.MarshalToString(float64(0.1234567))
-	should.Nil(err)
-	should.Equal("0.123457", output)
-	output, err = api.MarshalToString(float32(0.1234567))
-	should.Nil(err)
-	should.Equal("0.123457", output)
-}
-
-func Benchmark_jsoniter_float(b *testing.B) {
-	b.ReportAllocs()
-	input := []byte(`1.1123,`)
-	iter := NewIterator(ConfigDefault)
-	for n := 0; n < b.N; n++ {
-		iter.ResetBytes(input)
-		iter.ReadFloat64()
-	}
-}
-
-func Benchmark_json_float(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		result := float64(0)
-		json.Unmarshal([]byte(`1.1`), &result)
-	}
-}

jsoniter_interface_test.go

@@ -1,164 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"testing"
-	"unsafe"
-)
-
-func Test_write_array_of_interface(t *testing.T) {
-	should := require.New(t)
-	array := []interface{}{"hello"}
-	str, err := MarshalToString(array)
-	should.Nil(err)
-	should.Equal(`["hello"]`, str)
-}
-
-func Test_write_map_of_interface(t *testing.T) {
-	should := require.New(t)
-	val := map[string]interface{}{"hello": "world"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"hello":"world"}`, str)
-}
-
-func Test_write_map_of_interface_in_struct(t *testing.T) {
-	type TestObject struct {
-		Field map[string]interface{}
-	}
-	should := require.New(t)
-	val := TestObject{map[string]interface{}{"hello": "world"}}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"Field":{"hello":"world"}}`, str)
-}
-
-func Test_write_map_of_interface_in_struct_with_two_fields(t *testing.T) {
-	type TestObject struct {
-		Field  map[string]interface{}
-		Field2 string
-	}
-	should := require.New(t)
-	val := TestObject{map[string]interface{}{"hello": "world"}, ""}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Contains(str, `"Field":{"hello":"world"}`)
-}
-
-type MyInterface interface {
-	Hello() string
-}
-
-type MyString string
-
-func (ms MyString) Hello() string {
-	return string(ms)
-}
-
-func Test_write_map_of_custom_interface(t *testing.T) {
-	should := require.New(t)
-	myStr := MyString("world")
-	should.Equal("world", myStr.Hello())
-	val := map[string]MyInterface{"hello": myStr}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"hello":"world"}`, str)
-}
-
-func Test_write_interface(t *testing.T) {
-	should := require.New(t)
-	var val interface{}
-	val = "hello"
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`"hello"`, str)
-}
-
-func Test_read_interface(t *testing.T) {
-	should := require.New(t)
-	var val interface{}
-	err := UnmarshalFromString(`"hello"`, &val)
-	should.Nil(err)
-	should.Equal("hello", val)
-}
-
-func Test_read_custom_interface(t *testing.T) {
-	should := require.New(t)
-	var val MyInterface
-	RegisterTypeDecoderFunc("jsoniter.MyInterface", func(ptr unsafe.Pointer, iter *Iterator) {
-		*((*MyInterface)(ptr)) = MyString(iter.ReadString())
-	})
-	err := UnmarshalFromString(`"hello"`, &val)
-	should.Nil(err)
-	should.Equal("hello", val.Hello())
-}
-
-func Test_decode_object_contain_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field interface{}
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = 1024
-	should.Nil(UnmarshalFromString(`{"Field": "hello"}`, &obj))
-	should.Equal("hello", obj.Field)
-}
-
-func Test_decode_object_contain_non_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field MyInterface
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = MyString("abc")
-	should.Nil(UnmarshalFromString(`{"Field": "hello"}`, &obj))
-	should.Equal(MyString("hello"), obj.Field)
-}
-
-func Test_encode_object_contain_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field interface{}
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = 1024
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":1024}`, str)
-}
-
-func Test_encode_object_contain_non_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field MyInterface
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = MyString("hello")
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Field":"hello"}`, str)
-}
-
-func Test_nil_non_empty_interface(t *testing.T) {
-	ConfigDefault.cleanEncoders()
-	ConfigDefault.cleanDecoders()
-	type TestObject struct {
-		Field []MyInterface
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	b := []byte(`{"Field":["AAA"]}`)
-	should.NotNil(json.Unmarshal(b, &obj))
-	should.NotNil(Unmarshal(b, &obj))
-}
-
-func Test_read_large_number_as_interface(t *testing.T) {
-	should := require.New(t)
-	var val interface{}
-	err := Config{UseNumber: true}.Froze().UnmarshalFromString(`123456789123456789123456789`, &val)
-	should.Nil(err)
-	output, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`123456789123456789123456789`, output)
-}

jsoniter_io_test.go

@@ -1,84 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"io"
-	"testing"
-)
-
-func Test_read_by_one(t *testing.T) {
-	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 1)
-	b := iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
-	iter.unreadByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	iter.unreadByte()
-	if iter.Error == nil {
-		t.FailNow()
-	}
-	iter.Error = nil
-	b = iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
-}
-
-func Test_read_by_two(t *testing.T) {
-	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
-	b := iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
-	b = iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'b' {
-		t.Fatal(b)
-	}
-	iter.unreadByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	iter.unreadByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	b = iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'a' {
-		t.Fatal(b)
-	}
-}
-
-func Test_read_until_eof(t *testing.T) {
-	iter := Parse(ConfigDefault, bytes.NewBufferString("abc"), 2)
-	iter.readByte()
-	iter.readByte()
-	b := iter.readByte()
-	if iter.Error != nil {
-		t.Fatal(iter.Error)
-	}
-	if b != 'c' {
-		t.Fatal(b)
-	}
-	iter.readByte()
-	if iter.Error != io.EOF {
-		t.Fatal(iter.Error)
-	}
-}

jsoniter_large_file_test.go

@@ -1,49 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-//func Test_large_file(t *testing.T) {
-//	file, err := os.Open("/tmp/large-file.json")
-//	if err != nil {
-//		t.Fatal(err)
-//	}
-//	iter := Parse(file, 4096)
-//	count := 0
-//	for iter.ReadArray() {
-//		iter.Skip()
-//		count++
-//	}
-//	if count != 11351 {
-//		t.Fatal(count)
-//	}
-//}
-
-func Benchmark_jsoniter_large_file(b *testing.B) {
-	b.ReportAllocs()
-	for n := 0; n < b.N; n++ {
-		file, _ := os.Open("/tmp/large-file.json")
-		iter := Parse(ConfigDefault, file, 4096)
-		count := 0
-		for iter.ReadArray() {
-			iter.Skip()
-			count++
-		}
-		file.Close()
-	}
-}
-
-func Benchmark_json_large_file(b *testing.B) {
-	b.ReportAllocs()
-	for n := 0; n < b.N; n++ {
-		file, _ := os.Open("/tmp/large-file.json")
-		bytes, _ := ioutil.ReadAll(file)
-		file.Close()
-		result := []struct{}{}
-		json.Unmarshal(bytes, &result)
-	}
-}

jsoniter_map_test.go

@@ -1,122 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"math/big"
-	"testing"
-)
-
-func Test_read_map(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{"hello": "world"}`)
-	m := map[string]string{"1": "2"}
-	iter.ReadVal(&m)
-	copy(iter.buf, []byte{0, 0, 0, 0, 0, 0})
-	should.Equal(map[string]string{"1": "2", "hello": "world"}, m)
-}
-
-func Test_read_map_of_interface(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{"hello": "world"}`)
-	m := map[string]interface{}{"1": "2"}
-	iter.ReadVal(&m)
-	should.Equal(map[string]interface{}{"1": "2", "hello": "world"}, m)
-	iter = ParseString(ConfigDefault, `{"hello": "world"}`)
-	should.Equal(map[string]interface{}{"hello": "world"}, iter.Read())
-}
-
-func Test_map_wrapper_any_get_all(t *testing.T) {
-	should := require.New(t)
-	any := Wrap(map[string][]int{"Field1": {1, 2}})
-	should.Equal(`{"Field1":1}`, any.Get('*', 0).ToString())
-}
-
-func Test_write_val_map(t *testing.T) {
-	should := require.New(t)
-	val := map[string]string{"1": "2"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_slice_of_map(t *testing.T) {
-	should := require.New(t)
-	val := []map[string]string{{"1": "2"}}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`[{"1":"2"}]`, str)
-	val = []map[string]string{}
-	should.Nil(UnmarshalFromString(str, &val))
-	should.Equal("2", val[0]["1"])
-}
-
-func Test_encode_int_key_map(t *testing.T) {
-	should := require.New(t)
-	val := map[int]string{1: "2"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_decode_int_key_map(t *testing.T) {
-	should := require.New(t)
-	var val map[int]string
-	should.Nil(UnmarshalFromString(`{"1":"2"}`, &val))
-	should.Equal(map[int]string{1: "2"}, val)
-}
-
-func Test_encode_TextMarshaler_key_map(t *testing.T) {
-	should := require.New(t)
-	f, _, _ := big.ParseFloat("1", 10, 64, big.ToZero)
-	val := map[*big.Float]string{f: "2"}
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_decode_TextMarshaler_key_map(t *testing.T) {
-	should := require.New(t)
-	var val map[*big.Float]string
-	should.Nil(UnmarshalFromString(`{"1":"2"}`, &val))
-	str, err := MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`{"1":"2"}`, str)
-}
-
-func Test_map_key_with_escaped_char(t *testing.T) {
-	type Ttest struct {
-		Map map[string]string
-	}
-	var jsonBytes = []byte(`
-	{
-	    "Map":{
-		"k\"ey": "val"
-	    }
-	}`)
-	should := require.New(t)
-	{
-		var obj Ttest
-		should.Nil(json.Unmarshal(jsonBytes, &obj))
-		should.Equal(map[string]string{"k\"ey": "val"}, obj.Map)
-	}
-	{
-		var obj Ttest
-		should.Nil(Unmarshal(jsonBytes, &obj))
-		should.Equal(map[string]string{"k\"ey": "val"}, obj.Map)
-	}
-}
-
-func Test_encode_map_with_sorted_keys(t *testing.T) {
-	should := require.New(t)
-	m := map[string]interface{}{
-		"3": 3,
-		"1": 1,
-		"2": 2,
-	}
-	bytes, err := json.Marshal(m)
-	should.Nil(err)
-	output, err := ConfigCompatibleWithStandardLibrary.MarshalToString(m)
-	should.Nil(err)
-	should.Equal(string(bytes), output)
-}

jsoniter_null_test.go

@@ -1,119 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_read_null(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `null`)
-	should.True(iter.ReadNil())
-	iter = ParseString(ConfigDefault, `null`)
-	should.Nil(iter.Read())
-}
-
-func Test_write_null(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigDefault, buf, 4096)
-	stream.WriteNil()
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal("null", buf.String())
-}
-
-func Test_encode_null(t *testing.T) {
-	should := require.New(t)
-	str, err := MarshalToString(nil)
-	should.Nil(err)
-	should.Equal("null", str)
-}
-
-func Test_decode_null_object(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[null,"a"]`)
-	iter.ReadArray()
-	if iter.ReadObject() != "" {
-		t.FailNow()
-	}
-	iter.ReadArray()
-	if iter.ReadString() != "a" {
-		t.FailNow()
-	}
-	type TestObject struct {
-		Field string
-	}
-	objs := []TestObject{}
-	should.Nil(UnmarshalFromString("[null]", &objs))
-	should.Len(objs, 1)
-}
-
-func Test_decode_null_array(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[null,"a"]`)
-	iter.ReadArray()
-	if iter.ReadArray() != false {
-		t.FailNow()
-	}
-	iter.ReadArray()
-	if iter.ReadString() != "a" {
-		t.FailNow()
-	}
-}
-
-func Test_decode_null_string(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `[null,"a"]`)
-	should.True(iter.ReadArray())
-	should.Equal("", iter.ReadString())
-	should.True(iter.ReadArray())
-	should.Equal("a", iter.ReadString())
-}
-
-func Test_decode_null_skip(t *testing.T) {
-	iter := ParseString(ConfigDefault, `[null,"a"]`)
-	iter.ReadArray()
-	iter.Skip()
-	iter.ReadArray()
-	if iter.ReadString() != "a" {
-		t.FailNow()
-	}
-}
-
-func Test_encode_nil_map(t *testing.T) {
-	should := require.New(t)
-	type Ttest map[string]string
-	var obj1 Ttest
-	output, err := json.Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = json.Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-}
-
-func Test_encode_nil_array(t *testing.T) {
-	should := require.New(t)
-	type Ttest []string
-	var obj1 Ttest
-	output, err := json.Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = json.Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-	output, err = Marshal(&obj1)
-	should.Nil(err)
-	should.Equal("null", string(output))
-}

jsoniter_object_test.go

@@ -1,434 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_empty_object(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{}`)
-	field := iter.ReadObject()
-	should.Equal("", field)
-	iter = ParseString(ConfigDefault, `{}`)
-	iter.ReadObjectCB(func(iter *Iterator, field string) bool {
-		should.FailNow("should not call")
-		return true
-	})
-}
-
-func Test_one_field(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{"a": "b"}`)
-	field := iter.ReadObject()
-	should.Equal("a", field)
-	value := iter.ReadString()
-	should.Equal("b", value)
-	field = iter.ReadObject()
-	should.Equal("", field)
-	iter = ParseString(ConfigDefault, `{"a": "b"}`)
-	should.True(iter.ReadObjectCB(func(iter *Iterator, field string) bool {
-		should.Equal("a", field)
-		return true
-	}))
-}
-
-func Test_two_field(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `{ "a": "b" , "c": "d" }`)
-	field := iter.ReadObject()
-	should.Equal("a", field)
-	value := iter.ReadString()
-	should.Equal("b", value)
-	field = iter.ReadObject()
-	should.Equal("c", field)
-	value = iter.ReadString()
-	should.Equal("d", value)
-	field = iter.ReadObject()
-	should.Equal("", field)
-	iter = ParseString(ConfigDefault, `{"field1": "1", "field2": 2}`)
-	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
-		switch field {
-		case "field1":
-			iter.ReadString()
-		case "field2":
-			iter.ReadInt64()
-		default:
-			iter.ReportError("bind object", "unexpected field")
-		}
-	}
-}
-
-func Test_object_wrapper_any_get_all(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 []int
-		Field2 []int
-	}
-	any := Wrap(TestObject{[]int{1, 2}, []int{3, 4}})
-	should.Contains(any.Get('*', 0).ToString(), `"Field2":3`)
-}
-
-func Test_write_object(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(Config{IndentionStep: 2}.Froze(), buf, 4096)
-	stream.WriteObjectStart()
-	stream.WriteObjectField("hello")
-	stream.WriteInt(1)
-	stream.WriteMore()
-	stream.WriteObjectField("world")
-	stream.WriteInt(2)
-	stream.WriteObjectEnd()
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal("{\n  \"hello\":1,\n  \"world\":2\n}", buf.String())
-}
-
-func Test_decode_one_field_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"field1": "hello"}`, &obj))
-	should.Equal("hello", obj.Field1)
-}
-
-func Test_decode_two_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
-}
-
-func Test_decode_three_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
-	should.Equal("c", obj.Field3)
-}
-
-func Test_decode_four_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-}
-
-func Test_decode_five_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Field2 string
-		Field3 string
-		Field4 string
-		Field5 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-}
-
-func Test_decode_ten_fields_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1  string
-		Field2  string
-		Field3  string
-		Field4  string
-		Field5  string
-		Field6  string
-		Field7  string
-		Field8  string
-		Field9  string
-		Field10 string
-	}
-	obj := TestObject{}
-	should.Nil(UnmarshalFromString(`{}`, &obj))
-	should.Equal("", obj.Field1)
-	should.Nil(UnmarshalFromString(`{"Field1": "a", "Field2": "b", "Field3": "c", "Field4": "d", "Field5": "e"}`, &obj))
-	should.Equal("a", obj.Field1)
-	should.Equal("b", obj.Field2)
-	should.Equal("c", obj.Field3)
-	should.Equal("d", obj.Field4)
-	should.Equal("e", obj.Field5)
-}
-
-func Test_decode_struct_field_with_tag(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string `json:"field-1"`
-		Field2 string `json:"-"`
-		Field3 int    `json:",string"`
-	}
-	obj := TestObject{Field2: "world"}
-	UnmarshalFromString(`{"field-1": "hello", "field2": "", "Field3": "100"}`, &obj)
-	should.Equal("hello", obj.Field1)
-	should.Equal("world", obj.Field2)
-	should.Equal(100, obj.Field3)
-}
-
-func Test_decode_struct_field_with_tag_string(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 int `json:",string"`
-	}
-	obj := TestObject{Field1: 100}
-	should.Nil(UnmarshalFromString(`{"Field1": "100"}`, &obj))
-	should.Equal(100, obj.Field1)
-}
-
-func Test_write_val_zero_field_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-	}
-	obj := TestObject{}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{}`, str)
-}
-
-func Test_write_val_one_field_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string `json:"field-1"`
-	}
-	obj := TestObject{"hello"}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"field-1":"hello"}`, str)
-}
-
-func Test_mixed(t *testing.T) {
-	should := require.New(t)
-	type AA struct {
-		ID      int                    `json:"id"`
-		Payload map[string]interface{} `json:"payload"`
-		buf     *bytes.Buffer          `json:"-"`
-	}
-	aa := AA{}
-	err := UnmarshalFromString(` {"id":1, "payload":{"account":"123","password":"456"}}`, &aa)
-	should.Nil(err)
-	should.Equal(1, aa.ID)
-	should.Equal("123", aa.Payload["account"])
-}
-
-func Test_omit_empty(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string `json:"field-1,omitempty"`
-		Field2 string `json:"field-2,omitempty"`
-		Field3 string `json:"field-3,omitempty"`
-	}
-	obj := TestObject{}
-	obj.Field2 = "hello"
-	str, err := MarshalToString(&obj)
-	should.Nil(err)
-	should.Equal(`{"field-2":"hello"}`, str)
-}
-
-func Test_recursive_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 string
-		Me     *TestObject
-	}
-	obj := TestObject{}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Contains(str, `"Field1":""`)
-	should.Contains(str, `"Me":null`)
-	err = UnmarshalFromString(str, &obj)
-	should.Nil(err)
-}
-
-func Test_one_field_struct(t *testing.T) {
-	should := require.New(t)
-	type YetYetAnotherObject struct {
-		Field string
-	}
-	type YetAnotherObject struct {
-		Field *YetYetAnotherObject
-	}
-	type AnotherObject struct {
-		Field *YetAnotherObject
-	}
-	type TestObject struct {
-		Me *AnotherObject
-	}
-	obj := TestObject{&AnotherObject{&YetAnotherObject{&YetYetAnotherObject{"abc"}}}}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
-	str, err = MarshalToString(&obj)
-	should.Nil(err)
-	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
-}
-
-func Test_encode_anonymous_struct(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field string
-	}
-	str, err := MarshalToString(struct {
-		TestObject
-		Field int
-	}{
-		Field: 100,
-	})
-	should.Nil(err)
-	should.Equal(`{"Field":100}`, str)
-}
-
-func Test_decode_anonymous_struct(t *testing.T) {
-	should := require.New(t)
-	type Inner struct {
-		Key string `json:"key"`
-	}
-
-	type Outer struct {
-		Inner
-	}
-	var outer Outer
-	j := []byte("{\"key\":\"value\"}")
-	should.Nil(Unmarshal(j, &outer))
-	should.Equal("value", outer.Key)
-}
-
-func Test_multiple_level_anonymous_struct(t *testing.T) {
-	type Level1 struct {
-		Field1 string
-	}
-	type Level2 struct {
-		Level1
-		Field2 string
-	}
-	type Level3 struct {
-		Level2
-		Field3 string
-	}
-	should := require.New(t)
-	obj := Level3{Level2{Level1{"1"}, "2"}, "3"}
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	fmt.Println(output)
-	should.Contains(output, `"Field1":"1"`)
-	should.Contains(output, `"Field2":"2"`)
-	should.Contains(output, `"Field3":"3"`)
-}
-
-func Test_multiple_level_anonymous_struct_with_ptr(t *testing.T) {
-	type Level1 struct {
-		Field1 string
-		Field2 string
-		Field4 string
-	}
-	type Level2 struct {
-		*Level1
-		Field2 string
-		Field3 string
-	}
-	type Level3 struct {
-		*Level2
-		Field3 string
-	}
-	should := require.New(t)
-	obj := Level3{&Level2{&Level1{"1", "", "4"}, "2", ""}, "3"}
-	output, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Contains(output, `"Field1":"1"`)
-	should.Contains(output, `"Field2":"2"`)
-	should.Contains(output, `"Field3":"3"`)
-	should.Contains(output, `"Field4":"4"`)
-}
-
-func Test_shadow_struct_field(t *testing.T) {
-	should := require.New(t)
-	type omit *struct{}
-	type CacheItem struct {
-		Key    string `json:"key"`
-		MaxAge int    `json:"cacheAge"`
-	}
-	output, err := MarshalToString(struct {
-		*CacheItem
-
-		// Omit bad keys
-		OmitMaxAge omit `json:"cacheAge,omitempty"`
-
-		// Add nice keys
-		MaxAge int `json:"max_age"`
-	}{
-		CacheItem: &CacheItem{
-			Key:    "value",
-			MaxAge: 100,
-		},
-		MaxAge: 20,
-	})
-	should.Nil(err)
-	should.Contains(output, `"key":"value"`)
-	should.Contains(output, `"max_age":20`)
-}
-
-func Test_decode_nested(t *testing.T) {
-	type StructOfString struct {
-		Field1 string
-		Field2 string
-	}
-	iter := ParseString(ConfigDefault, `[{"field1": "hello"}, null, {"field2": "world"}]`)
-	slice := []*StructOfString{}
-	iter.ReadVal(&slice)
-	if len(slice) != 3 {
-		fmt.Println(iter.Error)
-		t.Fatal(len(slice))
-	}
-	if slice[0].Field1 != "hello" {
-		fmt.Println(iter.Error)
-		t.Fatal(slice[0])
-	}
-	if slice[1] != nil {
-		fmt.Println(iter.Error)
-		t.Fatal(slice[1])
-	}
-	if slice[2].Field2 != "world" {
-		fmt.Println(iter.Error)
-		t.Fatal(slice[2])
-	}
-}

jsoniter_optional_test.go

@@ -1,46 +0,0 @@
-package jsoniter
-
-import (
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_encode_optional_int_pointer(t *testing.T) {
-	should := require.New(t)
-	var ptr *int
-	str, err := MarshalToString(ptr)
-	should.Nil(err)
-	should.Equal("null", str)
-	val := 100
-	ptr = &val
-	str, err = MarshalToString(ptr)
-	should.Nil(err)
-	should.Equal("100", str)
-}
-
-func Test_decode_struct_with_optional_field(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 *string
-		Field2 *string
-	}
-	obj := TestObject{}
-	UnmarshalFromString(`{"field1": null, "field2": "world"}`, &obj)
-	should.Nil(obj.Field1)
-	should.Equal("world", *obj.Field2)
-}
-
-func Test_encode_struct_with_optional_field(t *testing.T) {
-	should := require.New(t)
-	type TestObject struct {
-		Field1 *string
-		Field2 *string
-	}
-	obj := TestObject{}
-	world := "world"
-	obj.Field2 = &world
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Contains(str, `"Field1":null`)
-	should.Contains(str, `"Field2":"world"`)
-}

jsoniter_raw_message_test.go

@@ -1,74 +0,0 @@
-package jsoniter
-
-import (
-	"encoding/json"
-	"github.com/json-iterator/go/require"
-	"testing"
-)
-
-func Test_json_RawMessage(t *testing.T) {
-	should := require.New(t)
-	var data json.RawMessage
-	should.Nil(Unmarshal([]byte(`[1,2,3]`), &data))
-	should.Equal(`[1,2,3]`, string(data))
-	str, err := MarshalToString(data)
-	should.Nil(err)
-	should.Equal(`[1,2,3]`, str)
-}
-
-func Test_jsoniter_RawMessage(t *testing.T) {
-	should := require.New(t)
-	var data RawMessage
-	should.Nil(Unmarshal([]byte(`[1,2,3]`), &data))
-	should.Equal(`[1,2,3]`, string(data))
-	str, err := MarshalToString(data)
-	should.Nil(err)
-	should.Equal(`[1,2,3]`, str)
-}
-
-func Test_json_RawMessage_in_struct(t *testing.T) {
-	type TestObject struct {
-		Field1 string
-		Field2 json.RawMessage
-	}
-	should := require.New(t)
-	var data TestObject
-	should.Nil(Unmarshal([]byte(`{"field1": "hello", "field2": [1,2,3]}`), &data))
-	should.Equal(` [1,2,3]`, string(data.Field2))
-	should.Equal(`hello`, data.Field1)
-}
-
-func Test_decode_map_of_raw_message(t *testing.T) {
-	should := require.New(t)
-	type RawMap map[string]*json.RawMessage
-	b := []byte("{\"test\":[{\"key\":\"value\"}]}")
-	var rawMap RawMap
-	should.Nil(Unmarshal(b, &rawMap))
-	should.Equal(`[{"key":"value"}]`, string(*rawMap["test"]))
-	type Inner struct {
-		Key string `json:"key"`
-	}
-	var inner []Inner
-	Unmarshal(*rawMap["test"], &inner)
-	should.Equal("value", inner[0].Key)
-}
-
-func Test_encode_map_of_raw_message(t *testing.T) {
-	should := require.New(t)
-	type RawMap map[string]*json.RawMessage
-	value := json.RawMessage("[]")
-	rawMap := RawMap{"hello": &value}
-	output, err := MarshalToString(rawMap)
-	should.Nil(err)
-	should.Equal(`{"hello":[]}`, output)
-}
-
-func Test_encode_map_of_jsoniter_raw_message(t *testing.T) {
-	should := require.New(t)
-	type RawMap map[string]*RawMessage
-	value := RawMessage("[]")
-	rawMap := RawMap{"hello": &value}
-	output, err := MarshalToString(rawMap)
-	should.Nil(err)
-	should.Equal(`{"hello":[]}`, output)
-}

jsoniter_reflect_native_test.go

@@ -1,154 +0,0 @@
-package jsoniter
-
-import (
-	"fmt"
-	"testing"
-)
-
-func Test_reflect_str(t *testing.T) {
-	iter := ParseString(ConfigDefault, `"hello"`)
-	str := ""
-	iter.ReadVal(&str)
-	if str != "hello" {
-		fmt.Println(iter.Error)
-		t.Fatal(str)
-	}
-}
-
-func Test_reflect_ptr_str(t *testing.T) {
-	iter := ParseString(ConfigDefault, `"hello"`)
-	var str *string
-	iter.ReadVal(&str)
-	if *str != "hello" {
-		t.Fatal(str)
-	}
-}
-
-func Test_reflect_int(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int8(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int8(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int16(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int16(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int32(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int32(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_int64(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := int64(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint8(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint8(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint16(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint16(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint32(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint32(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_uint64(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := uint64(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_byte(t *testing.T) {
-	iter := ParseString(ConfigDefault, `123`)
-	val := byte(0)
-	iter.ReadVal(&val)
-	if val != 123 {
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_float32(t *testing.T) {
-	iter := ParseString(ConfigDefault, `1.23`)
-	val := float32(0)
-	iter.ReadVal(&val)
-	if val != 1.23 {
-		fmt.Println(iter.Error)
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_float64(t *testing.T) {
-	iter := ParseString(ConfigDefault, `1.23`)
-	val := float64(0)
-	iter.ReadVal(&val)
-	if val != 1.23 {
-		fmt.Println(iter.Error)
-		t.Fatal(val)
-	}
-}
-
-func Test_reflect_bool(t *testing.T) {
-	iter := ParseString(ConfigDefault, `true`)
-	val := false
-	iter.ReadVal(&val)
-	if val != true {
-		fmt.Println(iter.Error)
-		t.Fatal(val)
-	}
-}

jsoniter_string_test.go

@@ -1,205 +0,0 @@
-package jsoniter
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"github.com/json-iterator/go/require"
-	"testing"
-	"unicode/utf8"
-)
-
-func Test_read_normal_string(t *testing.T) {
-	cases := map[string]string{
-		`"0123456789012345678901234567890123456789"`: `0123456789012345678901234567890123456789`,
-		`""`:      ``,
-		`"hello"`: `hello`,
-	}
-	for input, output := range cases {
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input)
-			should.Equal(output, iter.ReadString())
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
-			should.Equal(output, iter.ReadString())
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input)
-			should.Equal(output, string(iter.ReadStringAsSlice()))
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
-			should.Equal(output, string(iter.ReadStringAsSlice()))
-		})
-	}
-}
-
-func Test_read_exotic_string(t *testing.T) {
-	cases := map[string]string{
-		`"hel\"lo"`:      `hel"lo`,
-		`"hel\nlo"`:      "hel\nlo",
-		`"\u4e2d\u6587"`: "中文",
-		`"\ud83d\udc4a"`: "\xf0\x9f\x91\x8a", // surrogate
-	}
-	for input, output := range cases {
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := ParseString(ConfigDefault, input)
-			should.Equal(output, iter.ReadString())
-		})
-		t.Run(fmt.Sprintf("%v:%v", input, output), func(t *testing.T) {
-			should := require.New(t)
-			iter := Parse(ConfigDefault, bytes.NewBufferString(input), 2)
-			should.Equal(output, iter.ReadString())
-		})
-	}
-}
-
-func Test_read_string_as_interface(t *testing.T) {
-	should := require.New(t)
-	iter := ParseString(ConfigDefault, `"hello"`)
-	should.Equal("hello", iter.Read())
-}
-
-func Test_write_string(t *testing.T) {
-	should := require.New(t)
-	str, err := MarshalToString("hello")
-	should.Equal(`"hello"`, str)
-	should.Nil(err)
-	str, err = MarshalToString(`hel"lo`)
-	should.Equal(`"hel\"lo"`, str)
-	should.Nil(err)
-}
-
-func Test_write_val_string(t *testing.T) {
-	should := require.New(t)
-	buf := &bytes.Buffer{}
-	stream := NewStream(ConfigDefault, buf, 4096)
-	stream.WriteVal("hello")
-	stream.Flush()
-	should.Nil(stream.Error)
-	should.Equal(`"hello"`, buf.String())
-}
-
-func Test_decode_slash(t *testing.T) {
-	should := require.New(t)
-	var obj interface{}
-	should.NotNil(json.Unmarshal([]byte("\\"), &obj))
-	should.NotNil(UnmarshalFromString("\\", &obj))
-}
-
-func Test_html_escape(t *testing.T) {
-	should := require.New(t)
-	output, err := json.Marshal(`>`)
-	should.Nil(err)
-	should.Equal(`"\u003e"`, string(output))
-	output, err = ConfigCompatibleWithStandardLibrary.Marshal(`>`)
-	should.Nil(err)
-	should.Equal(`"\u003e"`, string(output))
-}
-
-func Test_string_encode_with_std(t *testing.T) {
-	should := require.New(t)
-	for i := 0; i < utf8.RuneSelf; i++ {
-		input := string([]byte{byte(i)})
-		stdOutputBytes, err := json.Marshal(input)
-		should.Nil(err)
-		stdOutput := string(stdOutputBytes)
-		jsoniterOutputBytes, err := ConfigCompatibleWithStandardLibrary.Marshal(input)
-		should.Nil(err)
-		jsoniterOutput := string(jsoniterOutputBytes)
-		should.Equal(stdOutput, jsoniterOutput)
-	}
-}
-
-func Test_string_encode_with_std_without_html_escape(t *testing.T) {
-	api := Config{EscapeHtml: false}.Froze()
-	should := require.New(t)
-	for i := 0; i < utf8.RuneSelf; i++ {
-		input := string([]byte{byte(i)})
-		buf := &bytes.Buffer{}
-		encoder := json.NewEncoder(buf)
-		encoder.SetEscapeHTML(false)
-		err := encoder.Encode(input)
-		should.Nil(err)
-		stdOutput := buf.String()
-		stdOutput = stdOutput[:len(stdOutput)-1]
-		jsoniterOutputBytes, err := api.Marshal(input)
-		should.Nil(err)
-		jsoniterOutput := string(jsoniterOutputBytes)
-		should.Equal(stdOutput, jsoniterOutput)
-	}
-}
-
-func Test_unicode(t *testing.T) {
-	should := require.New(t)
-	output , _ := MarshalToString(map[string]interface{}{"a": "数字山谷"})
-	should.Equal(`{"a":"数字山谷"}`, output)
-	output , _ = Config{EscapeHtml: false}.Froze().MarshalToString(map[string]interface{}{"a": "数字山谷"})
-	should.Equal(`{"a":"数字山谷"}`, output)
-}
-
-func Test_unicode_and_escape(t *testing.T) {
-	should := require.New(t)
-	output , err := MarshalToString(`"数字山谷"`)
-	should.Nil(err)
-	should.Equal(`"\"数字山谷\""`, output)
-	output , err = ConfigFastest.MarshalToString(`"数字山谷"`)
-	should.Nil(err)
-	should.Equal(`"\"数字山谷\""`, output)
-}
-
-func Test_unsafe_unicode(t *testing.T) {
-	should := require.New(t)
-	output , err := MarshalToString("he\u2029\u2028he")
-	should.Nil(err)
-	should.Equal(`"he\u2029\u2028he"`, output)
-	output , err = ConfigFastest.MarshalToString("he\u2029\u2028he")
-	should.Nil(err)
-	should.Equal("\"he\u2029\u2028he\"", output)
-}
-
-func Benchmark_jsoniter_unicode(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		iter := ParseString(ConfigDefault, `"\ud83d\udc4a"`)
-		iter.ReadString()
-	}
-}
-
-func Benchmark_jsoniter_ascii(b *testing.B) {
-	iter := NewIterator(ConfigDefault)
-	input := []byte(`"hello, world! hello, world!"`)
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
-		iter.ResetBytes(input)
-		iter.ReadString()
-	}
-}
-
-func Benchmark_jsoniter_string_as_bytes(b *testing.B) {
-	iter := ParseString(ConfigDefault, `"hello, world!"`)
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
-		iter.ResetBytes(iter.buf)
-		iter.ReadStringAsSlice()
-	}
-}
-
-func Benchmark_json_unicode(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		result := ""
-		json.Unmarshal([]byte(`"\ud83d\udc4a"`), &result)
-	}
-}
-
-func Benchmark_json_ascii(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		result := ""
-		json.Unmarshal([]byte(`"hello"`), &result)
-	}
-}