Merge pull request #635 from molon/fix-tests

encoding/json: Compatibility optimization

.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,21 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/modern-go/concurrent"
+  packages = ["."]
+  revision = "e0a39a4cb4216ea8db28e22a69f4ec25610d513a"
+  version = "1.0.0"
+
+[[projects]]
+  name = "github.com/modern-go/reflect2"
+  packages = ["."]
+  revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd"
+  version = "1.0.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "ea54a775e5a354cb015502d2e7aa4b74230fc77e894f34a838b268c25ec8eeb8"
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,26 @@
+# 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"
+
+ignored = ["github.com/davecgh/go-spew*","github.com/google/gofuzz*","github.com/stretchr/testify*"]
+
+[[constraint]]
+  name = "github.com/modern-go/reflect2"
+  version = "1.0.1"

README.md

@@ -1,6 +1,12 @@
+[![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)](https://pkg.go.dev/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"
 
 # Benchmark
 
@@ -10,14 +16,17 @@ Source code: https://github.com/json-iterator/go-benchmark/blob/master/src/githu
 
 Raw Result (easyjson requires static code generation)
 
-| | ns/op | allocation bytes | allocation times |
-| --- | --- | --- | --- |
-| std decode | 35510 ns/op | 1960 B/op | 99 allocs/op |
-| easyjson decode | 8499 ns/op | 160 B/op | 4 allocs/op |
-| jsoniter decode | 5623 ns/op | 160 B/op | 3 allocs/op |
-| std encode | 2213 ns/op | 712 B/op | 5 allocs/op |
-| easyjson encode | 883 ns/op | 576 B/op | 3 allocs/op |
-| jsoniter encode | 837 ns/op | 384 B/op | 4 allocs/op |
+|                 | ns/op       | allocation bytes | allocation times |
+| --------------- | ----------- | ---------------- | ---------------- |
+| std decode      | 35510 ns/op | 1960 B/op        | 99 allocs/op     |
+| easyjson decode | 8499 ns/op  | 160 B/op         | 4 allocs/op      |
+| jsoniter decode | 5623 ns/op  | 160 B/op         | 3 allocs/op      |
+| std encode      | 2213 ns/op  | 712 B/op         | 5 allocs/op      |
+| easyjson encode | 883 ns/op   | 576 B/op         | 3 allocs/op      |
+| jsoniter encode | 837 ns/op   | 384 B/op         | 4 allocs/op      |
+
+Always benchmark with your own workload.
+The result depends heavily on the data input.
 
 # Usage
 
@@ -30,11 +39,13 @@ import "encoding/json"
 json.Marshal(&data)
 ```
 
-with 
+with
 
 ```go
-import "github.com/json-iterator/go"
-jsoniter.Marshal(&data)
+import jsoniter "github.com/json-iterator/go"
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+json.Marshal(&data)
 ```
 
 Replace
@@ -47,8 +58,10 @@ json.Unmarshal(input, &data)
 with
 
 ```go
-import "github.com/json-iterator/go"
-jsoniter.Unmarshal(input, &data)
+import jsoniter "github.com/json-iterator/go"
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+json.Unmarshal(input, &data)
 ```
 
 [More documentation](http://jsoniter.com/migrate-from-go-std.html)
@@ -61,4 +74,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

@@ -0,0 +1,150 @@
+package jsoniter
+
+import (
+	"bytes"
+	"io"
+)
+
+// RawMessage to make replace json with jsoniter
+type RawMessage []byte
+
+// Unmarshal adapts to json/encoding Unmarshal API
+//
+// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
+// Refer to https://godoc.org/encoding/json#Unmarshal for more information
+func Unmarshal(data []byte, v interface{}) error {
+	return ConfigDefault.Unmarshal(data, v)
+}
+
+// UnmarshalFromString is a 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...)
+}
+
+// Marshal adapts to json/encoding Marshal API
+//
+// Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
+// Refer to https://godoc.org/encoding/json#Marshal for more information
+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)
+}
+
+// NewDecoder adapts to json/stream NewDecoder API.
+//
+// NewDecoder returns a new decoder that reads from r.
+//
+// Instead of a json/encoding Decoder, an Decoder is returned
+// Refer to https://godoc.org/encoding/json#NewDecoder for more information
+func NewDecoder(reader io.Reader) *Decoder {
+	return ConfigDefault.NewDecoder(reader)
+}
+
+// Decoder reads and decodes JSON values from an input stream.
+// Decoder provides identical APIs with json/stream Decoder (Token() and UseNumber() are in progress)
+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 {
+		return nil
+	}
+	return adapter.iter.Error
+}
+
+// More is there more?
+func (adapter *Decoder) More() bool {
+	iter := adapter.iter
+	if iter.Error != nil {
+		return false
+	}
+	c := iter.nextToken()
+	if c == 0 {
+		return false
+	}
+	iter.unreadByte()
+	return c != ']' && c != '}'
+}
+
+// Buffered remaining buffer
+func (adapter *Decoder) Buffered() io.Reader {
+	remaining := adapter.iter.buf[adapter.iter.head:adapter.iter.tail]
+	return bytes.NewReader(remaining)
+}
+
+// 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(adapter.iter.cfg.extraExtensions)
+}
+
+// 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(adapter.iter.cfg.extraExtensions)
+}
+
+// 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) {
+	config := adapter.stream.cfg.configBeforeFrozen
+	config.IndentionStep = len(indent)
+	adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
+}
+
+// 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.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
+}
+
+// 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"
+	"github.com/modern-go/reflect2"
 	"io"
 	"reflect"
+	"strconv"
+	"unsafe"
 )
 
+// 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,70 @@ 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)
+	if any == nil {
+		stream.WriteNil()
+		return
+	}
+	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
+	if any.val[0] == '+' || any.val[0] == '-' {
+		startPos = 1
+	}
+
+	if any.val[0] == '-' {
+		flag = -1
+	}
+
+	endPos := startPos
+	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
+
+	if any.val[0] == '-' {
+		return 0
+	}
+	if any.val[0] == '+' {
+		startPos = 1
+	}
+
+	endPos := startPos
+	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/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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,101 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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)
+	any2 := jsoniter.WrapFloat64(-1.1)
+	should.Equal(float64(12.3), any.ToFloat64())
+	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/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+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/json-iterator/go"
+	"github.com/stretchr/testify/require"
 	"testing"
 )
 
 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,121 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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")
+}

any_tests/jsoniter_any_string_test.go

@@ -0,0 +1,58 @@
+package any_tests
+
+import (
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+// 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/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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,229 @@
+package test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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)
+}
+
+type caseSensitiveStruct struct {
+	A string `json:"a"`
+	B string `json:"b,omitempty"`
+	C *C     `json:"C,omitempty"`
+}
+
+type C struct {
+	D int64 `json:"D,omitempty"`
+	E *E    `json:"e,omitempty"`
+}
+
+type E struct {
+	F string `json:"F,omitempty"`
+}
+
+func Test_CaseSensitive(t *testing.T) {
+	should := require.New(t)
+
+	testCases := []struct {
+		input          string
+		expectedOutput string
+		caseSensitive  bool
+	}{
+		{
+			input:          `{"A":"foo","B":"bar"}`,
+			expectedOutput: `{"a":"foo","b":"bar"}`,
+			caseSensitive:  false,
+		},
+		{
+			input:          `{"a":"foo","b":"bar"}`,
+			expectedOutput: `{"a":"foo","b":"bar"}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","b":"bar","C":{"D":10}}`,
+			expectedOutput: `{"a":"foo","b":"bar","C":{"D":10}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","B":"bar","c":{"d":10}}`,
+			expectedOutput: `{"a":"foo"}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","C":{"d":10}}`,
+			expectedOutput: `{"a":"foo","C":{}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","C":{"D":10,"e":{"f":"baz"}}}`,
+			expectedOutput: `{"a":"foo","C":{"D":10,"e":{}}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
+			expectedOutput: `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"A":"foo","c":{"d":10,"E":{"f":"baz"}}}`,
+			expectedOutput: `{"a":"foo","C":{"D":10,"e":{"F":"baz"}}}`,
+			caseSensitive:  false,
+		},
+	}
+
+	for _, tc := range testCases {
+		val := caseSensitiveStruct{}
+		err := jsoniter.Config{CaseSensitive: tc.caseSensitive}.Froze().UnmarshalFromString(tc.input, &val)
+		should.Nil(err)
+
+		output, err := jsoniter.MarshalToString(val)
+		should.Nil(err)
+		should.Equal(tc.expectedOutput, output)
+	}
+}
+
+type structWithElevenFields struct {
+	A string `json:"A,omitempty"`
+	B string `json:"B,omitempty"`
+	C string `json:"C,omitempty"`
+	D string `json:"d,omitempty"`
+	E string `json:"e,omitempty"`
+	F string `json:"f,omitempty"`
+	G string `json:"g,omitempty"`
+	H string `json:"h,omitempty"`
+	I string `json:"i,omitempty"`
+	J string `json:"j,omitempty"`
+	K string `json:"k,omitempty"`
+}
+
+func Test_CaseSensitive_MoreThanTenFields(t *testing.T) {
+	should := require.New(t)
+
+	testCases := []struct {
+		input          string
+		expectedOutput string
+		caseSensitive  bool
+	}{
+		{
+			input:          `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6","g":"7","h":"8","i":"9","j":"10","k":"11"}`,
+			expectedOutput: `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6","g":"7","h":"8","i":"9","j":"10","k":"11"}`,
+			caseSensitive:  true,
+		},
+		{
+			input:          `{"a":"1","b":"2","c":"3","D":"4","E":"5","F":"6"}`,
+			expectedOutput: `{"A":"1","B":"2","C":"3","d":"4","e":"5","f":"6"}`,
+			caseSensitive:  false,
+		},
+		{
+			input:          `{"A":"1","b":"2","d":"4","E":"5"}`,
+			expectedOutput: `{"A":"1","d":"4"}`,
+			caseSensitive:  true,
+		},
+	}
+
+	for _, tc := range testCases {
+		val := structWithElevenFields{}
+		err := jsoniter.Config{CaseSensitive: tc.caseSensitive}.Froze().UnmarshalFromString(tc.input, &val)
+		should.Nil(err)
+
+		output, err := jsoniter.MarshalToString(val)
+		should.Nil(err)
+		should.Equal(tc.expectedOutput, output)
+	}
+}
+
+type onlyTaggedFieldStruct struct {
+	A      string `json:"a"`
+	B      string
+	FSimpl F `json:"f_simpl"`
+	ISimpl I
+	FPtr   *F `json:"f_ptr"`
+	IPtr   *I
+	F
+	*I
+}
+
+type F struct {
+	G string `json:"g"`
+	H string
+}
+
+type I struct {
+	J string `json:"j"`
+	K string
+}
+
+func Test_OnlyTaggedField(t *testing.T) {
+	should := require.New(t)
+
+	obj := onlyTaggedFieldStruct{
+		A:      "a",
+		B:      "b",
+		FSimpl: F{G: "g", H: "h"},
+		ISimpl: I{J: "j", K: "k"},
+		FPtr:   &F{G: "g", H: "h"},
+		IPtr:   &I{J: "j", K: "k"},
+		F:      F{G: "g", H: "h"},
+		I:      &I{J: "j", K: "k"},
+	}
+
+	output, err := jsoniter.Config{OnlyTaggedField: true}.Froze().Marshal(obj)
+	should.Nil(err)
+
+	m := make(map[string]interface{})
+	err = jsoniter.Unmarshal(output, &m)
+	should.Nil(err)
+
+	should.Equal(map[string]interface{}{
+		"a": "a",
+		"f_simpl": map[string]interface{}{
+			"g": "g",
+		},
+		"f_ptr": map[string]interface{}{
+			"g": "g",
+		},
+		"g": "g",
+		"j": "j",
+	}, m)
+}

api_tests/decoder_test.go

@@ -1,17 +1,27 @@
-package jsoniter
+package test
 
 import (
 	"bytes"
 	"encoding/json"
-	"github.com/json-iterator/go/require"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
 	"io/ioutil"
 	"testing"
 )
 
+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 +43,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))
@@ -61,10 +57,8 @@ func Test_use_number(t *testing.T) {
 	should.Equal(json.Number("123"), obj2)
 }
 
-func Test_use_number_for_unmarshal(t *testing.T) {
+func Test_decoder_more(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)
+	decoder := jsoniter.NewDecoder(bytes.NewBufferString("abcde"))
+	should.True(decoder.More())
 }

api_tests/encoder_18_test.go

@@ -0,0 +1,46 @@
+//+build go1.8
+
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+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 (
+	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+// 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/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+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))
+}

api_tests/marshal_json_escape_test.go

@@ -0,0 +1,47 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+)
+
+var marshalConfig = jsoniter.Config{
+	EscapeHTML:             false,
+	SortMapKeys:            true,
+	ValidateJsonRawMessage: true,
+}.Froze()
+
+type Container struct {
+	Bar interface{}
+}
+
+func (c *Container) MarshalJSON() ([]byte, error) {
+	return marshalConfig.Marshal(&c.Bar)
+}
+
+func TestEncodeEscape(t *testing.T) {
+	should := require.New(t)
+
+	container := &Container{
+		Bar: []string{"123<ab>", "ooo"},
+	}
+	out, err := marshalConfig.Marshal(container)
+	should.Nil(err)
+	bufout := string(out)
+
+	var stdbuf bytes.Buffer
+	stdenc := json.NewEncoder(&stdbuf)
+	stdenc.SetEscapeHTML(false)
+	err = stdenc.Encode(container)
+	should.Nil(err)
+	stdout := string(stdbuf.Bytes())
+	if stdout[len(stdout)-1:] == "\n" {
+		stdout = stdout[:len(stdout)-1]
+	}
+
+	should.Equal(stdout, bufout)
+}

api_tests/marshal_json_test.go

@@ -0,0 +1,36 @@
+package test
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"testing"
+	"github.com/stretchr/testify/require"
+)
+
+
+type Foo struct {
+	Bar interface{}
+}
+
+func (f Foo) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	err := json.NewEncoder(&buf).Encode(f.Bar)
+	return buf.Bytes(), err
+}
+
+
+// Standard Encoder has trailing newline.
+func TestEncodeMarshalJSON(t *testing.T) {
+
+	foo := Foo {
+		Bar: 123,
+	}
+	should := require.New(t)
+	var buf, stdbuf bytes.Buffer
+	enc := jsoniter.ConfigCompatibleWithStandardLibrary.NewEncoder(&buf)
+	enc.Encode(foo)
+	stdenc := json.NewEncoder(&stdbuf)
+	stdenc.Encode(foo)
+	should.Equal(stdbuf.Bytes(), buf.Bytes())
+}

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"
+	"github.com/json-iterator/go"
+	"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 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)
+		}
+	}
+}

benchmarks/stream_test.go

@@ -0,0 +1,128 @@
+package test
+
+import (
+	"bytes"
+	"strconv"
+	"testing"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+func Benchmark_stream_encode_big_object(b *testing.B) {
+	var buf bytes.Buffer
+	var stream = jsoniter.NewStream(jsoniter.ConfigDefault, &buf, 100)
+	for i := 0; i < b.N; i++ {
+		buf.Reset()
+		stream.Reset(&buf)
+		encodeObject(stream)
+		if stream.Error != nil {
+			b.Errorf("error: %+v", stream.Error)
+		}
+	}
+}
+
+func TestEncodeObject(t *testing.T) {
+	var stream = jsoniter.NewStream(jsoniter.ConfigDefault, nil, 100)
+	encodeObject(stream)
+	if stream.Error != nil {
+		t.Errorf("error encoding a test object: %+v", stream.Error)
+		return
+	}
+	var m = make(map[string]interface{})
+	if err := jsoniter.Unmarshal(stream.Buffer(), &m); err != nil {
+		t.Errorf("error unmarshaling a test object: %+v", err)
+		return
+	}
+}
+
+func encodeObject(stream *jsoniter.Stream) {
+	stream.WriteObjectStart()
+
+	stream.WriteObjectField("objectId")
+	stream.WriteUint64(8838243212)
+
+	stream.WriteMore()
+	stream.WriteObjectField("name")
+	stream.WriteString("Jane Doe")
+
+	stream.WriteMore()
+	stream.WriteObjectField("address")
+	stream.WriteObjectStart()
+	for i, field := range addressFields {
+		if i != 0 {
+			stream.WriteMore()
+		}
+		stream.WriteObjectField(field.key)
+		stream.WriteString(field.val)
+	}
+
+	stream.WriteMore()
+	stream.WriteObjectField("geo")
+	{
+		stream.WriteObjectStart()
+		stream.WriteObjectField("latitude")
+		stream.WriteFloat64(-154.550817)
+		stream.WriteMore()
+		stream.WriteObjectField("longitude")
+		stream.WriteFloat64(-84.176159)
+		stream.WriteObjectEnd()
+
+	}
+	stream.WriteObjectEnd()
+
+	stream.WriteMore()
+	stream.WriteObjectField("specialties")
+	stream.WriteArrayStart()
+	for i, s := range specialties {
+		if i != 0 {
+			stream.WriteMore()
+		}
+		stream.WriteString(s)
+	}
+	stream.WriteArrayEnd()
+
+	stream.WriteMore()
+	for i, text := range longText {
+		if i != 0 {
+			stream.WriteMore()
+		}
+		stream.WriteObjectField("longText" + strconv.Itoa(i))
+		stream.WriteString(text)
+	}
+
+	for i := 0; i < 25; i++ {
+		num := i * 18328
+		stream.WriteMore()
+		stream.WriteObjectField("integerField" + strconv.Itoa(i))
+		stream.WriteInt64(int64(num))
+	}
+
+	stream.WriteObjectEnd()
+}
+
+type field struct{ key, val string }
+
+var (
+	addressFields = []field{
+		{"address1", "123 Example St"},
+		{"address2", "Apartment 5D, Suite 3"},
+		{"city", "Miami"},
+		{"state", "FL"},
+		{"postalCode", "33133"},
+		{"country", "US"},
+	}
+	specialties = []string{
+		"Web Design",
+		"Go Programming",
+		"Tennis",
+		"Cycling",
+		"Mixed martial arts",
+	}
+	longText = []string{
+		`Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.`,
+		`Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?`,
+		`But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and I will give you a complete account of the system, and expound the actual teachings of the great explorer of the truth, the master-builder of human happiness. No one rejects, dislikes, or avoids pleasure itself, because it is pleasure, but because those who do not know how to pursue pleasure rationally encounter consequences that are extremely painful. Nor again is there anyone who loves or pursues or desires to obtain pain of itself, because it is pain, but because occasionally circumstances occur in which toil and pain can procure him some great pleasure. To take a trivial example, which of us ever undertakes laborious physical exercise, except to obtain some advantage from it? But who has any right to find fault with a man who chooses to enjoy a pleasure that has no annoying consequences, or one who avoids a pain that produces no resultant pleasure?`,
+		`At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat.`,
+		`On the other hand, we denounce with righteous indignation and dislike men who are so beguiled and demoralized by the charms of pleasure of the moment, so blinded by desire, that they cannot foresee the pain and trouble that are bound to ensue; and equal blame belongs to those who fail in their duty through weakness of will, which is the same as saying through shrinking from toil and pain. These cases are perfectly simple and easy to distinguish. In a free hour, when our power of choice is untrammelled and when nothing prevents our being able to do what we like best, every pleasure is to be welcomed and every pain avoided. But in certain circumstances and owing to the claims of duty or the obligations of business it will frequently occur that pleasures have to be repudiated and annoyances accepted. The wise man therefore always holds in these matters to this principle of selection: he rejects pleasures to secure other greater pleasures, or else he endures pains to avoid worse pains.`,
+	}
+)

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,375 @@
+package jsoniter
+
+import (
+	"encoding/json"
+	"io"
+	"reflect"
+	"sync"
+	"unsafe"
+
+	"github.com/modern-go/concurrent"
+	"github.com/modern-go/reflect2"
+)
+
+// 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
+	CaseSensitive                 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)
+	DecoderOf(typ reflect2.Type) ValDecoder
+	EncoderOf(typ reflect2.Type) ValEncoder
+}
+
+// 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()
+
+type frozenConfig struct {
+	configBeforeFrozen            Config
+	sortMapKeys                   bool
+	indentionStep                 int
+	objectFieldMustBeSimpleString bool
+	onlyTaggedField               bool
+	disallowUnknownFields         bool
+	decoderCache                  *concurrent.Map
+	encoderCache                  *concurrent.Map
+	encoderExtension              Extension
+	decoderExtension              Extension
+	extraExtensions               []Extension
+	streamPool                    *sync.Pool
+	iteratorPool                  *sync.Pool
+	caseSensitive                 bool
+}
+
+func (cfg *frozenConfig) initCache() {
+	cfg.decoderCache = concurrent.NewMap()
+	cfg.encoderCache = concurrent.NewMap()
+}
+
+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 = concurrent.NewMap()
+
+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)
+}
+
+// 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,
+		caseSensitive:                 cfg.CaseSensitive,
+	}
+	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)
+	}
+	api.encoderExtension = encoderExtension
+	api.decoderExtension = decoderExtension
+	api.configBeforeFrozen = cfg
+	return api
+}
+
+func (cfg Config) frozeWithCacheReuse(extraExtensions []Extension) *frozenConfig {
+	api := getFrozenConfigFromCache(cfg)
+	if api != nil {
+		return api
+	}
+	api = cfg.Froze().(*frozenConfig)
+	for _, extension := range extraExtensions {
+		api.RegisterExtension(extension)
+	}
+	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))
+		defer cfg.ReturnIterator(iter)
+		iter.Read()
+		if iter.Error != nil && iter.Error != io.EOF {
+			stream.WriteRaw("null")
+		} else {
+			stream.WriteRaw(string(rawMessage))
+		}
+	}, func(ptr unsafe.Pointer) bool {
+		return len(*((*json.RawMessage)(ptr))) == 0
+	}}
+	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) {
+		exitingValue := *((*interface{})(ptr))
+		if exitingValue != nil && reflect.TypeOf(exitingValue).Kind() == reflect.Ptr {
+			iter.ReadVal(exitingValue)
+			return
+		}
+		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.extraExtensions = append(cfg.extraExtensions, extension)
+	copied := cfg.configBeforeFrozen
+	cfg.configBeforeFrozen = copied
+}
+
+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(cfg.extraExtensions).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
+}

example_test.go

@@ -1,10 +1,9 @@
-package jsoniter_test
+package jsoniter
 
 import (
 	"fmt"
 	"os"
-
-	"github.com/json-iterator/go"
+	"strings"
 )
 
 func ExampleMarshal() {
@@ -18,7 +17,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 +36,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 +45,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 +56,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 +67,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 +77,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 +88,34 @@ 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
 }
+
+func ExampleMyKey() {
+	hello := MyKey("hello")
+	output, _ := Marshal(map[*MyKey]string{&hello: "world"})
+	fmt.Println(string(output))
+	obj := map[*MyKey]string{}
+	Unmarshal(output, &obj)
+	for k, v := range obj {
+		fmt.Println(*k, v)
+	}
+	// Output:
+	// {"Hello":"world"}
+	// Hel world
+}
+
+type MyKey string
+
+func (m *MyKey) MarshalText() ([]byte, error) {
+	return []byte(strings.Replace(string(*m), "h", "H", -1)), nil
+}
+
+func (m *MyKey) UnmarshalText(text []byte) error {
+	*m = MyKey(text[:3])
+	return nil
+}

extension_tests/decoder_test.go

@@ -0,0 +1,223 @@
+package test
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"strconv"
+	"testing"
+	"time"
+	"unsafe"
+)
+
+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)
+}
+
+type CustomEncoderAttachmentTestStruct struct {
+	Value int32 `json:"value"`
+}
+
+type CustomEncoderAttachmentTestStructEncoder struct {}
+
+func (c *CustomEncoderAttachmentTestStructEncoder) Encode(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+	attachVal, ok := stream.Attachment.(int)
+	stream.WriteRaw(`"`)
+	stream.WriteRaw(fmt.Sprintf("%t %d", ok, attachVal))
+	stream.WriteRaw(`"`)
+}
+
+func (c *CustomEncoderAttachmentTestStructEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+	return false
+}
+
+func Test_custom_encoder_attachment(t *testing.T) {
+
+	jsoniter.RegisterTypeEncoder("test.CustomEncoderAttachmentTestStruct", &CustomEncoderAttachmentTestStructEncoder{})
+	expectedValue := 17
+	should := require.New(t)
+	buf := &bytes.Buffer{}
+	stream := jsoniter.NewStream(jsoniter.Config{SortMapKeys: true}.Froze(), buf, 4096)
+	stream.Attachment = expectedValue
+	val := map[string]CustomEncoderAttachmentTestStruct{"a": {}}
+	stream.WriteVal(val)
+	stream.Flush()
+	should.Nil(stream.Error)
+	should.Equal("{\"a\":\"true 17\"}", buf.String())
+}
+
+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())
+}
+
+const flow1 = `
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}`
+
+const flow2 = `
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+{"A":"hello"}
+`
+
+type (
+	Type1 struct {
+		A string
+	}
+
+	Type2 struct {
+		A string
+	}
+)
+
+func (t *Type2) UnmarshalJSON(data []byte) error {
+	return nil
+}
+
+func (t *Type2) MarshalJSON() ([]byte, error) {
+	return nil, nil
+}
+
+func TestType1NoFinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow1))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type1{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}
+
+func TestType1FinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow2))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type1{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}
+
+func TestType2NoFinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow1))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type2{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}
+
+func TestType2FinalLF(t *testing.T) {
+	reader := bytes.NewReader([]byte(flow2))
+	dec := jsoniter.NewDecoder(reader)
+
+	i := 0
+	for dec.More() {
+		data := &Type2{}
+		if err := dec.Decode(data); err != nil {
+			t.Errorf("at %v got %v", i, err)
+		}
+		i++
+	}
+}

extension_tests/extension_test.go

@@ -0,0 +1,120 @@
+package test
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+	"github.com/stretchr/testify/require"
+	"reflect"
+	"strconv"
+	"testing"
+	"unsafe"
+)
+
+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)
+}
+
+func Test_customize_map_key_encoder(t *testing.T) {
+	should := require.New(t)
+	cfg := jsoniter.Config{}.Froze()
+	cfg.RegisterExtension(&testMapKeyExtension{})
+	m := map[int]int{1: 2}
+	output, err := cfg.MarshalToString(m)
+	should.NoError(err)
+	should.Equal(`{"2":2}`, output)
+	m = map[int]int{}
+	should.NoError(cfg.UnmarshalFromString(output, &m))
+	should.Equal(map[int]int{1: 2}, m)
+}
+
+type testMapKeyExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *testMapKeyExtension) CreateMapKeyEncoder(typ reflect2.Type) jsoniter.ValEncoder {
+	if typ.Kind() == reflect.Int {
+		return &funcEncoder{
+			fun: func(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+				stream.WriteRaw(`"`)
+				stream.WriteInt(*(*int)(ptr) + 1)
+				stream.WriteRaw(`"`)
+			},
+		}
+	}
+	return nil
+}
+
+func (extension *testMapKeyExtension) CreateMapKeyDecoder(typ reflect2.Type) jsoniter.ValDecoder {
+	if typ.Kind() == reflect.Int {
+		return &funcDecoder{
+			fun: func(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+				i, err := strconv.Atoi(iter.ReadString())
+				if err != nil {
+					iter.ReportError("read map key", err.Error())
+					return
+				}
+				i--
+				*(*int)(ptr) = i
+			},
+		}
+	}
+	return nil
+}
+
+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/binary_as_string_codec.go

@@ -0,0 +1,238 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+	"unicode/utf8"
+	"unsafe"
+)
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      true,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      true,
+	'=':      true,
+	'>':      true,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
+
+var binaryType = reflect2.TypeOfPtr((*[]byte)(nil)).Elem()
+
+type BinaryAsStringExtension struct {
+	jsoniter.DummyExtension
+}
+
+func (extension *BinaryAsStringExtension) CreateEncoder(typ reflect2.Type) jsoniter.ValEncoder {
+	if typ == binaryType {
+		return &binaryAsStringCodec{}
+	}
+	return nil
+}
+
+func (extension *BinaryAsStringExtension) CreateDecoder(typ reflect2.Type) jsoniter.ValDecoder {
+	if typ == binaryType {
+		return &binaryAsStringCodec{}
+	}
+	return nil
+}
+
+type binaryAsStringCodec struct {
+}
+
+func (codec *binaryAsStringCodec) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	rawBytes := iter.ReadStringAsSlice()
+	bytes := make([]byte, 0, len(rawBytes))
+	for i := 0; i < len(rawBytes); i++ {
+		b := rawBytes[i]
+		if b == '\\' {
+			b2 := rawBytes[i+1]
+			if b2 != '\\' {
+				iter.ReportError("decode binary as string", `\\x is only supported escape`)
+				return
+			}
+			b3 := rawBytes[i+2]
+			if b3 != 'x' {
+				iter.ReportError("decode binary as string", `\\x is only supported escape`)
+				return
+			}
+			b4 := rawBytes[i+3]
+			b5 := rawBytes[i+4]
+			i += 4
+			b = readHex(iter, b4, b5)
+		}
+		bytes = append(bytes, b)
+	}
+	*(*[]byte)(ptr) = bytes
+}
+func (codec *binaryAsStringCodec) IsEmpty(ptr unsafe.Pointer) bool {
+	return len(*((*[]byte)(ptr))) == 0
+}
+func (codec *binaryAsStringCodec) Encode(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+	newBuffer := writeBytes(stream.Buffer(), *(*[]byte)(ptr))
+	stream.SetBuffer(newBuffer)
+}
+
+func readHex(iter *jsoniter.Iterator, b1, b2 byte) byte {
+	var ret byte
+	if b1 >= '0' && b1 <= '9' {
+		ret = b1 - '0'
+	} else if b1 >= 'a' && b1 <= 'f' {
+		ret = b1 - 'a' + 10
+	} else {
+		iter.ReportError("read hex", "expects 0~9 or a~f, but found "+string([]byte{b1}))
+		return 0
+	}
+	ret *= 16
+	if b2 >= '0' && b2 <= '9' {
+		ret += b2 - '0'
+	} else if b2 >= 'a' && b2 <= 'f' {
+		ret += b2 - 'a' + 10
+	} else {
+		iter.ReportError("read hex", "expects 0~9 or a~f, but found "+string([]byte{b2}))
+		return 0
+	}
+	return ret
+}
+
+var hex = "0123456789abcdef"
+
+func writeBytes(space []byte, s []byte) []byte {
+	space = append(space, '"')
+	// write string, the fast path, without utf8 and escape support
+	var i int
+	var c byte
+	for i, c = range s {
+		if c < utf8.RuneSelf && safeSet[c] {
+			space = append(space, c)
+		} else {
+			break
+		}
+	}
+	if i == len(s)-1 {
+		space = append(space, '"')
+		return space
+	}
+	return writeBytesSlowPath(space, s[i:])
+}
+
+func writeBytesSlowPath(space []byte, s []byte) []byte {
+	start := 0
+	// for the remaining parts, we process them char by char
+	var i int
+	var b byte
+	for i, b = range s {
+		if b >= utf8.RuneSelf {
+			space = append(space, '\\', '\\', 'x', hex[b>>4], hex[b&0xF])
+			start = i + 1
+			continue
+		}
+		if safeSet[b] {
+			continue
+		}
+		if start < i {
+			space = append(space, s[start:i]...)
+		}
+		space = append(space, '\\', '\\', 'x', hex[b>>4], hex[b&0xF])
+		start = i + 1
+	}
+	if start < len(s) {
+		space = append(space, s[start:]...)
+	}
+	return append(space, '"')
+}

extra/binary_as_string_codec_test.go

@@ -0,0 +1,32 @@
+package extra
+
+import (
+	"github.com/json-iterator/go"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func init() {
+	jsoniter.RegisterExtension(&BinaryAsStringExtension{})
+}
+
+func TestBinaryAsStringCodec(t *testing.T) {
+	t.Run("safe set", func(t *testing.T) {
+		should := require.New(t)
+		output, err := jsoniter.Marshal([]byte("hello"))
+		should.NoError(err)
+		should.Equal(`"hello"`, string(output))
+		var val []byte
+		should.NoError(jsoniter.Unmarshal(output, &val))
+		should.Equal(`hello`, string(val))
+	})
+	t.Run("non safe set", func(t *testing.T) {
+		should := require.New(t)
+		output, err := jsoniter.Marshal([]byte{1, 2, 3, 23})
+		should.NoError(err)
+		should.Equal(`"\\x01\\x02\\x03\\x17"`, string(output))
+		var val []byte
+		should.NoError(jsoniter.Unmarshal(output, &val))
+		should.Equal([]byte{1, 2, 3, 23}, val)
+	})
+}

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/modern-go/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,134 @@ 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()
+	case jsoniter.NilValue:
+		iter.Skip()
+		*((*string)(ptr)) = ""
 	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"
+		}
+	case jsoniter.NilValue:
+		iter.Skip()
+		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)
+	if len(str) == 0 {
+		str = "0"
+	}
+	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
+		}
+	case jsoniter.NilValue:
+		iter.Skip()
+		*((*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
+		}
+	case jsoniter.NilValue:
+		iter.Skip()
+		*((*float64)(ptr)) = 0
 	default:
-		iter.ReportError("FuzzyFloat32Decoder", "not number or string")
+		iter.ReportError("fuzzyFloat64Decoder", "not number or string")
 	}
 }

extra/fuzzy_decoder_test.go

@@ -1,89 +1,328 @@
 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)
+	should.Nil(jsoniter.UnmarshalFromString(`""`, &val))
+	should.Equal(int64(0), 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 +338,56 @@ 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)
+}
+
+func Test_null_to_string(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message string
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}
+
+func Test_null_to_int(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message int
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}
+
+func Test_null_to_float32(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message float32
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}
+
+func Test_null_to_float64(t *testing.T) {
+	should := require.New(t)
+	body := []byte(`null`)
+	var message float64
+	err := jsoniter.Unmarshal(body, &message)
+	should.NoError(err)
+}

extra/naming_strategy.go

@@ -2,9 +2,11 @@ package extra
 
 import (
 	"github.com/json-iterator/go"
+	"strings"
 	"unicode"
 )
 
+// SetNamingStrategy rename struct fields uniformly
 func SetNamingStrategy(translate func(string) string) {
 	jsoniter.RegisterExtension(&namingStrategyExtension{jsoniter.DummyExtension{}, translate})
 }
@@ -16,11 +18,25 @@ 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)}
+		if unicode.IsLower(rune(binding.Field.Name()[0])) || binding.Field.Name()[0] == '_'{
+			continue
+		}
+		tag, hastag := binding.Field.Tag().Lookup("json")
+		if hastag {
+			tagParts := strings.Split(tag, ",")
+			if tagParts[0] == "-" {
+				continue // hidden field
+			}
+			if tagParts[0] != "" {
+				continue // field explicitly named
+			}
+		}
+		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"
 )
 
@@ -21,3 +21,46 @@ func Test_lower_case_with_underscores(t *testing.T) {
 	should.Nil(err)
 	should.Equal(`{"user_name":"taowen","first_language":"Chinese"}`, string(output))
 }
+
+func Test_set_naming_strategy_with_overrides(t *testing.T) {
+	should := require.New(t)
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName      string `json:"UserName"`
+		FirstLanguage string
+	}{
+		UserName:      "taowen",
+		FirstLanguage: "Chinese",
+	})
+	should.Nil(err)
+	should.Equal(`{"UserName":"taowen","first_language":"Chinese"}`, string(output))
+}
+
+func Test_set_naming_strategy_with_omitempty(t *testing.T) {
+	should := require.New(t)
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName      string
+		FirstLanguage string `json:",omitempty"`
+	}{
+		UserName: "taowen",
+	})
+	should.Nil(err)
+	should.Equal(`{"user_name":"taowen"}`, string(output))
+}
+
+func Test_set_naming_strategy_with_private_field(t *testing.T) {
+	should := require.New(t)
+	SetNamingStrategy(LowerCaseWithUnderscores)
+	output, err := jsoniter.Marshal(struct {
+		UserName string
+		userId   int
+		_UserAge int
+	}{
+		UserName: "allen",
+		userId:   100,
+		_UserAge: 30,
+	})
+	should.Nil(err)
+	should.Equal(`{"user_name":"allen"}`, string(output))
+}

extra/privat_fields.go

@@ -2,9 +2,11 @@ package extra
 
 import (
 	"github.com/json-iterator/go"
+	"strings"
 	"unicode"
 )
 
+// SupportPrivateFields include private fields when encoding/decoding
 func SupportPrivateFields() {
 	jsoniter.RegisterExtension(&privateFieldsExtension{})
 }
@@ -15,10 +17,38 @@ 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}
+			tag, hastag := binding.Field.Tag().Lookup("json")
+			if !hastag {
+				binding.FromNames = []string{binding.Field.Name()}
+				binding.ToNames = []string{binding.Field.Name()}
+				continue
+			}
+			tagParts := strings.Split(tag, ",")
+			names := calcFieldNames(binding.Field.Name(), tagParts[0], tag)
+			binding.FromNames = names
+			binding.ToNames = names
 		}
 	}
 }
+
+func calcFieldNames(originalFieldName string, tagProvidedFieldName string, wholeTag string) []string {
+	// ignore?
+	if wholeTag == "-" {
+		return []string{}
+	}
+	// rename?
+	var fieldNames []string
+	if tagProvidedFieldName == "" {
+		fieldNames = []string{originalFieldName}
+	} else {
+		fieldNames = []string{tagProvidedFieldName}
+	}
+	// private?
+	isNotExported := unicode.IsLower(rune(originalFieldName[0]))
+	if isNotExported {
+		fieldNames = []string{}
+	}
+	return fieldNames
+}

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_adapter.go

@@ -1,120 +0,0 @@
-// 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 (
-	"bytes"
-	"io"
-)
-
-type RawMessage []byte
-
-// Unmarshal adapts to json/encoding Unmarshal API
-//
-// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
-// Refer to https://godoc.org/encoding/json#Unmarshal for more information
-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
-}
-
-func UnmarshalFromString(str string, v interface{}) error {
-	return ConfigDefault.UnmarshalFromString(str, v)
-}
-
-func Get(data []byte, path ...interface{}) Any {
-	return ConfigDefault.Get(data, path...)
-}
-
-// Marshal adapts to json/encoding Marshal API
-//
-// Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
-// Refer to https://godoc.org/encoding/json#Marshal for more information
-func Marshal(v interface{}) ([]byte, error) {
-	return ConfigDefault.Marshal(v)
-}
-
-func MarshalToString(v interface{}) (string, error) {
-	return ConfigDefault.MarshalToString(v)
-}
-
-// NewDecoder adapts to json/stream NewDecoder API.
-//
-// NewDecoder returns a new decoder that reads from r.
-//
-// Instead of a json/encoding Decoder, an Decoder is returned
-// Refer to https://godoc.org/encoding/json#NewDecoder for more information
-func NewDecoder(reader io.Reader) *Decoder {
-	return ConfigDefault.NewDecoder(reader)
-}
-
-// Decoder reads and decodes JSON values from an input stream.
-// Decoder provides identical APIs with json/stream Decoder (Token() and UseNumber() are in progress)
-type Decoder struct {
-	iter *Iterator
-}
-
-func (adapter *Decoder) Decode(obj interface{}) error {
-	adapter.iter.ReadVal(obj)
-	err := adapter.iter.Error
-	if err == io.EOF {
-		return nil
-	}
-	return adapter.iter.Error
-}
-
-func (adapter *Decoder) More() bool {
-	return adapter.iter.head != adapter.iter.tail
-}
-
-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()
-}
-
-func NewEncoder(writer io.Writer) *Encoder {
-	return ConfigDefault.NewEncoder(writer)
-}
-
-type Encoder struct {
-	stream *Stream
-}
-
-func (adapter *Encoder) Encode(val interface{}) error {
-	adapter.stream.WriteVal(val)
-	adapter.stream.Flush()
-	return adapter.stream.Error
-}
-
-func (adapter *Encoder) SetIndent(prefix, indent string) {
-	adapter.stream.cfg.indentionStep = len(indent)
-}
-
-func (adapter *Encoder) SetEscapeHTML(escapeHtml bool) {
-	config := adapter.stream.cfg.configBeforeFrozen
-	config.EscapeHtml = escapeHtml
-	adapter.stream.cfg = config.Froze()
-}

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.go

@@ -1,282 +0,0 @@
-//
-// 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 (
-	"fmt"
-	"io"
-)
-
-type ValueType int
-
-const (
-	Invalid ValueType = iota
-	String
-	Number
-	Nil
-	Bool
-	Array
-	Object
-)
-
-var hexDigits []byte
-var valueTypes []ValueType
-
-func init() {
-	hexDigits = make([]byte, 256)
-	for i := 0; i < len(hexDigits); i++ {
-		hexDigits[i] = 255
-	}
-	for i := '0'; i <= '9'; i++ {
-		hexDigits[i] = byte(i - '0')
-	}
-	for i := 'a'; i <= 'f'; i++ {
-		hexDigits[i] = byte((i - 'a') + 10)
-	}
-	for i := 'A'; i <= 'F'; i++ {
-		hexDigits[i] = byte((i - 'A') + 10)
-	}
-	valueTypes = make([]ValueType, 256)
-	for i := 0; i < len(valueTypes); i++ {
-		valueTypes[i] = Invalid
-	}
-	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
-}
-
-// Iterator is a fast and flexible JSON parser
-type Iterator struct {
-	cfg              *frozenConfig
-	reader           io.Reader
-	buf              []byte
-	head             int
-	tail             int
-	captureStartedAt int
-	captured         []byte
-	Error            error
-}
-
-// Create creates an empty Iterator instance
-func NewIterator(cfg *frozenConfig) *Iterator {
-	return &Iterator{
-		cfg:    cfg,
-		reader: nil,
-		buf:    nil,
-		head:   0,
-		tail:   0,
-	}
-}
-
-// Parse parses a json buffer in io.Reader into an Iterator instance
-func Parse(cfg *frozenConfig, reader io.Reader, bufSize int) *Iterator {
-	return &Iterator{
-		cfg:    cfg,
-		reader: reader,
-		buf:    make([]byte, bufSize),
-		head:   0,
-		tail:   0,
-	}
-}
-
-// ParseBytes parses a json byte slice into an Iterator instance
-func ParseBytes(cfg *frozenConfig, input []byte) *Iterator {
-	return &Iterator{
-		cfg:    cfg,
-		reader: nil,
-		buf:    input,
-		head:   0,
-		tail:   len(input),
-	}
-}
-
-// ParseString parses a json string into an Iterator instance
-func ParseString(cfg *frozenConfig, input string) *Iterator {
-	return ParseBytes(cfg, []byte(input))
-}
-
-func (iter *Iterator) Config() *frozenConfig {
-	return iter.cfg
-}
-
-// Reset can reset an Iterator instance for another json buffer in io.Reader
-func (iter *Iterator) Reset(reader io.Reader) *Iterator {
-	iter.reader = reader
-	iter.head = 0
-	iter.tail = 0
-	return iter
-}
-
-// ResetBytes can reset an Iterator instance for another json byte slice
-func (iter *Iterator) ResetBytes(input []byte) *Iterator {
-	iter.reader = nil
-	iter.buf = input
-	iter.head = 0
-	iter.tail = len(input)
-	return iter
-}
-
-// WhatIsNext gets ValueType of relatively next json object
-func (iter *Iterator) WhatIsNext() ValueType {
-	valueType := valueTypes[iter.nextToken()]
-	iter.unreadByte()
-	return valueType
-}
-
-func (iter *Iterator) skipWhitespacesWithoutLoadMore() bool {
-	for i := iter.head; i < iter.tail; i++ {
-		c := iter.buf[i]
-		switch c {
-		case ' ', '\n', '\t', '\r':
-			continue
-		}
-		iter.head = i
-		return false
-	}
-	return true
-}
-
-func (iter *Iterator) nextToken() byte {
-	// a variation of skip whitespaces, returning the next non-whitespace token
-	for {
-		for i := iter.head; i < iter.tail; i++ {
-			c := iter.buf[i]
-			switch c {
-			case ' ', '\n', '\t', '\r':
-				continue
-			}
-			iter.head = i + 1
-			return c
-		}
-		if !iter.loadMore() {
-			return 0
-		}
-	}
-}
-
-func (iter *Iterator) ReportError(operation string, msg string) {
-	if iter.Error != nil {
-		if iter.Error != io.EOF {
-			return
-		}
-	}
-	peekStart := iter.head - 10
-	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]))
-}
-
-// CurrentBuffer gets current buffer as string
-func (iter *Iterator) CurrentBuffer() string {
-	peekStart := iter.head - 10
-	if peekStart < 0 {
-		peekStart = 0
-	}
-	return fmt.Sprintf("parsing %v ...|%s|... at %s", iter.head,
-		string(iter.buf[peekStart:iter.head]), string(iter.buf[0:iter.tail]))
-}
-
-func (iter *Iterator) readByte() (ret byte) {
-	if iter.head == iter.tail {
-		if iter.loadMore() {
-			ret = iter.buf[iter.head]
-			iter.head++
-			return ret
-		}
-		return 0
-	}
-	ret = iter.buf[iter.head]
-	iter.head++
-	return ret
-}
-
-func (iter *Iterator) loadMore() bool {
-	if iter.reader == nil {
-		if iter.Error == nil {
-			iter.head = iter.tail
-			iter.Error = io.EOF
-		}
-		return false
-	}
-	if iter.captureStartedAt != -1 {
-		iter.captured = append(iter.captured,
-			iter.buf[iter.captureStartedAt:iter.tail]...)
-		iter.captureStartedAt = 0
-	}
-	for {
-		n, err := iter.reader.Read(iter.buf)
-		if n == 0 {
-			if err != nil {
-				if iter.Error == nil {
-					iter.Error = err
-				}
-				return false
-			}
-		} else {
-			iter.head = 0
-			iter.tail = n
-			return true
-		}
-	}
-}
-
-func (iter *Iterator) unreadByte() {
-	if iter.head == 0 {
-		iter.ReportError("unreadByte", "unread too many bytes")
-		return
-	}
-	iter.head--
-	return
-}
-
-func (iter *Iterator) Read() interface{} {
-	valueType := iter.WhatIsNext()
-	switch valueType {
-	case String:
-		return iter.ReadString()
-	case Number:
-		return iter.ReadFloat64()
-	case Nil:
-		iter.skipFixedBytes(4) // null
-		return nil
-	case Bool:
-		return iter.ReadBool()
-	case Array:
-		arr := []interface{}{}
-		iter.ReadArrayCB(func(iter *Iterator) bool {
-			arr = append(arr, iter.Read())
-			return true
-		})
-		return arr
-	case Object:
-		obj := map[string]interface{}{}
-		iter.ReadObjectCB(func(Iter *Iterator, field string) bool {
-			obj[field] = iter.Read()
-			return true
-		})
-		return obj
-	default:
-		iter.ReportError("Read", fmt.Sprintf("unexpected value type: %v", valueType))
-		return nil
-	}
-}

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|

go.mod

@@ -0,0 +1,11 @@
+module github.com/json-iterator/go
+
+go 1.12
+
+require (
+	github.com/davecgh/go-spew v1.1.1
+	github.com/google/gofuzz v1.0.0
+	github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421
+	github.com/modern-go/reflect2 v1.0.2
+	github.com/stretchr/testify v1.8.0
+)

go.sum

@@ -0,0 +1,21 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

iter.go

@@ -0,0 +1,349 @@
+package jsoniter
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+// ValueType the type for JSON element
+type ValueType int
+
+const (
+	// 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
+var valueTypes []ValueType
+
+func init() {
+	hexDigits = make([]byte, 256)
+	for i := 0; i < len(hexDigits); i++ {
+		hexDigits[i] = 255
+	}
+	for i := '0'; i <= '9'; i++ {
+		hexDigits[i] = byte(i - '0')
+	}
+	for i := 'a'; i <= 'f'; i++ {
+		hexDigits[i] = byte((i - 'a') + 10)
+	}
+	for i := 'A'; i <= 'F'; i++ {
+		hexDigits[i] = byte((i - 'A') + 10)
+	}
+	valueTypes = make([]ValueType, 256)
+	for i := 0; i < len(valueTypes); i++ {
+		valueTypes[i] = InvalidValue
+	}
+	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 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
+	buf              []byte
+	head             int
+	tail             int
+	depth            int
+	captureStartedAt int
+	captured         []byte
+	Error            error
+	Attachment       interface{} // open for customized decoder
+}
+
+// NewIterator creates an empty Iterator instance
+func NewIterator(cfg API) *Iterator {
+	return &Iterator{
+		cfg:    cfg.(*frozenConfig),
+		reader: nil,
+		buf:    nil,
+		head:   0,
+		tail:   0,
+		depth:  0,
+	}
+}
+
+// Parse creates an Iterator instance from io.Reader
+func Parse(cfg API, reader io.Reader, bufSize int) *Iterator {
+	return &Iterator{
+		cfg:    cfg.(*frozenConfig),
+		reader: reader,
+		buf:    make([]byte, bufSize),
+		head:   0,
+		tail:   0,
+		depth:  0,
+	}
+}
+
+// ParseBytes creates an Iterator instance from byte array
+func ParseBytes(cfg API, input []byte) *Iterator {
+	return &Iterator{
+		cfg:    cfg.(*frozenConfig),
+		reader: nil,
+		buf:    input,
+		head:   0,
+		tail:   len(input),
+		depth:  0,
+	}
+}
+
+// ParseString creates an Iterator instance from string
+func ParseString(cfg API, input string) *Iterator {
+	return ParseBytes(cfg, []byte(input))
+}
+
+// Pool returns a pool can provide more iterator with same configuration
+func (iter *Iterator) Pool() IteratorPool {
+	return iter.cfg
+}
+
+// Reset reuse iterator instance by specifying another reader
+func (iter *Iterator) Reset(reader io.Reader) *Iterator {
+	iter.reader = reader
+	iter.head = 0
+	iter.tail = 0
+	iter.depth = 0
+	return iter
+}
+
+// ResetBytes reuse iterator instance by specifying another byte array as input
+func (iter *Iterator) ResetBytes(input []byte) *Iterator {
+	iter.reader = nil
+	iter.buf = input
+	iter.head = 0
+	iter.tail = len(input)
+	iter.depth = 0
+	return iter
+}
+
+// WhatIsNext gets ValueType of relatively next json element
+func (iter *Iterator) WhatIsNext() ValueType {
+	valueType := valueTypes[iter.nextToken()]
+	iter.unreadByte()
+	return valueType
+}
+
+func (iter *Iterator) skipWhitespacesWithoutLoadMore() bool {
+	for i := iter.head; i < iter.tail; i++ {
+		c := iter.buf[i]
+		switch c {
+		case ' ', '\n', '\t', '\r':
+			continue
+		}
+		iter.head = i
+		return false
+	}
+	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 {
+		for i := iter.head; i < iter.tail; i++ {
+			c := iter.buf[i]
+			switch c {
+			case ' ', '\n', '\t', '\r':
+				continue
+			}
+			iter.head = i + 1
+			return c
+		}
+		if !iter.loadMore() {
+			return 0
+		}
+	}
+}
+
+// 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 {
+			return
+		}
+	}
+	peekStart := iter.head - 10
+	if peekStart < 0 {
+		peekStart = 0
+	}
+	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 for debugging purpose
+func (iter *Iterator) CurrentBuffer() string {
+	peekStart := iter.head - 10
+	if peekStart < 0 {
+		peekStart = 0
+	}
+	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]))
+}
+
+func (iter *Iterator) readByte() (ret byte) {
+	if iter.head == iter.tail {
+		if iter.loadMore() {
+			ret = iter.buf[iter.head]
+			iter.head++
+			return ret
+		}
+		return 0
+	}
+	ret = iter.buf[iter.head]
+	iter.head++
+	return ret
+}
+
+func (iter *Iterator) loadMore() bool {
+	if iter.reader == nil {
+		if iter.Error == nil {
+			iter.head = iter.tail
+			iter.Error = io.EOF
+		}
+		return false
+	}
+	if iter.captured != nil {
+		iter.captured = append(iter.captured,
+			iter.buf[iter.captureStartedAt:iter.tail]...)
+		iter.captureStartedAt = 0
+	}
+	for {
+		n, err := iter.reader.Read(iter.buf)
+		if n == 0 {
+			if err != nil {
+				if iter.Error == nil {
+					iter.Error = err
+				}
+				return false
+			}
+		} else {
+			iter.head = 0
+			iter.tail = n
+			return true
+		}
+	}
+}
+
+func (iter *Iterator) unreadByte() {
+	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 StringValue:
+		return iter.ReadString()
+	case NumberValue:
+		if iter.cfg.configBeforeFrozen.UseNumber {
+			return json.Number(iter.readNumberAsString())
+		}
+		return iter.ReadFloat64()
+	case NilValue:
+		iter.skipFourBytes('n', 'u', 'l', 'l')
+		return nil
+	case BoolValue:
+		return iter.ReadBool()
+	case ArrayValue:
+		arr := []interface{}{}
+		iter.ReadArrayCB(func(iter *Iterator) bool {
+			var elem interface{}
+			iter.ReadVal(&elem)
+			arr = append(arr, elem)
+			return true
+		})
+		return arr
+	case ObjectValue:
+		obj := map[string]interface{}{}
+		iter.ReadMapCB(func(Iter *Iterator, field string) bool {
+			var elem interface{}
+			iter.ReadVal(&elem)
+			obj[field] = elem
+			return true
+		})
+		return obj
+	default:
+		iter.ReportError("Read", fmt.Sprintf("unexpected value type: %v", valueType))
+		return nil
+	}
+}
+
+// limit maximum depth of nesting, as allowed by https://tools.ietf.org/html/rfc7159#section-9
+const maxDepth = 10000
+
+func (iter *Iterator) incrementDepth() (success bool) {
+	iter.depth++
+	if iter.depth <= maxDepth {
+		return true
+	}
+	iter.ReportError("incrementDepth", "exceeded max depth")
+	return false
+}
+
+func (iter *Iterator) decrementDepth() (success bool) {
+	iter.depth--
+	if iter.depth >= 0 {
+		return true
+	}
+	iter.ReportError("decrementDepth", "unexpected negative nesting")
+	return false
+}

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,33 +19,46 @@ 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 == '[' {
+		if !iter.incrementDepth() {
+			return false
+		}
 		c = iter.nextToken()
 		if c != ']' {
 			iter.unreadByte()
 			if !callback(iter) {
+				iter.decrementDepth()
 				return false
 			}
-			for iter.nextToken() == ',' {
+			c = iter.nextToken()
+			for c == ',' {
 				if !callback(iter) {
+					iter.decrementDepth()
 					return false
 				}
+				c = iter.nextToken()
 			}
-			return true
+			if c != ']' {
+				iter.ReportError("ReadArrayCB", "expect ] in the end, but found "+string([]byte{c}))
+				iter.decrementDepth()
+				return false
+			}
+			return iter.decrementDepth()
 		}
-		return true
+		return iter.decrementDepth()
 	}
 	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,47 @@ 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,23 +125,25 @@ 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()
-			case invalidCharForNumber:
-				fallthrough
-			case dotInNumber:
+			case invalidCharForNumber, dotInNumber:
 				return iter.readFloat32SlowPath()
 			}
 			decimalPlaces++
@@ -131,7 +164,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 +190,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 +203,47 @@ 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,23 +262,25 @@ 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()
-			case invalidCharForNumber:
-				fallthrough
-			case dotInNumber:
+			case invalidCharForNumber, dotInNumber:
 				return iter.readFloat64SlowPath()
 			}
 			decimalPlaces++
@@ -221,6 +288,9 @@ non_decimal_loop:
 				return iter.readFloat64SlowPath()
 			}
 			value = (value << 3) + (value << 1) + uint64(ind)
+			if value > maxFloat64 {
+				return iter.readFloat64SlowPath()
+			}
 		}
 	}
 	return iter.readFloat64SlowPath()
@@ -231,6 +301,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 +313,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

@@ -9,6 +9,7 @@ var intDigits []int8
 
 const uint32SafeToMultiply10 = uint32(0xffffffff)/10 - 1
 const uint64SafeToMultiple10 = uint64(0xffffffffffffffff)/10 - 1
+const maxFloat64 = 1<<53 - 1
 
 func init() {
 	intDigits = make([]int8, 256)
@@ -20,14 +21,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 +47,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 +66,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 +76,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 +95,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 +105,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 +122,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 +135,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 +151,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 +187,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 +196,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 +204,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 +227,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 +244,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 +252,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 +326,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 < iter.tail && iter.buf[iter.head] == '.' {
+		iter.ReportError("assertInteger", "can not decode float as int")
+	}
+}

iter_object.go

@@ -0,0 +1,267 @@
+package jsoniter
+
+import (
+	"fmt"
+	"strings"
+)
+
+// 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' && !iter.cfg.caseSensitive {
+						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' && !iter.cfg.caseSensitive {
+				b += 'a' - 'A'
+			}
+			hash ^= int64(b)
+			hash *= 0x1000193
+		}
+		if !iter.loadMore() {
+			iter.ReportError("readFieldHash", `incomplete field name`)
+			return 0
+		}
+	}
+}
+
+func calcHash(str string, caseSensitive bool) int64 {
+	if !caseSensitive {
+		str = strings.ToLower(str)
+	}
+	hash := int64(0x811c9dc5)
+	for _, b := range []byte(str) {
+		hash ^= int64(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 == '{' {
+		if !iter.incrementDepth() {
+			return false
+		}
+		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) {
+				iter.decrementDepth()
+				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) {
+					iter.decrementDepth()
+					return false
+				}
+				c = iter.nextToken()
+			}
+			if c != '}' {
+				iter.ReportError("ReadObjectCB", `object not ended with }`)
+				iter.decrementDepth()
+				return false
+			}
+			return iter.decrementDepth()
+		}
+		if c == '}' {
+			return iter.decrementDepth()
+		}
+		iter.ReportError("ReadObjectCB", `expect " after {, but found `+string([]byte{c}))
+		iter.decrementDepth()
+		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 == '{' {
+		if !iter.incrementDepth() {
+			return false
+		}
+		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}))
+				iter.decrementDepth()
+				return false
+			}
+			if !callback(iter, field) {
+				iter.decrementDepth()
+				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}))
+					iter.decrementDepth()
+					return false
+				}
+				if !callback(iter, field) {
+					iter.decrementDepth()
+					return false
+				}
+				c = iter.nextToken()
+			}
+			if c != '}' {
+				iter.ReportError("ReadMapCB", `object not ended with }`)
+				iter.decrementDepth()
+				return false
+			}
+			return iter.decrementDepth()
+		}
+		if c == '}' {
+			return iter.decrementDepth()
+		}
+		iter.ReportError("ReadMapCB", `expect " after {, but found `+string([]byte{c}))
+		iter.decrementDepth()
+		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,130 @@
+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()
+}
+
+// SkipAndAppendBytes skips next JSON element and appends its content to
+// buffer, returning the result.
+func (iter *Iterator) SkipAndAppendBytes(buf []byte) []byte {
+	iter.startCaptureTo(buf, iter.head)
+	iter.Skip()
+	return iter.stopCapture()
+}
+
+func (iter *Iterator) startCaptureTo(buf []byte, captureStartedAt int) {
+	if iter.captured != nil {
+		panic("already in capture mode")
+	}
+	iter.captureStartedAt = captureStartedAt
+	iter.captured = buf
+}
+
+func (iter *Iterator) startCapture(captureStartedAt int) {
+	iter.startCaptureTo(make([]byte, 0, 32), captureStartedAt)
+}
+
+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
+	return append(captured, remaining...)
+}
+
+// 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,89 +1,98 @@
+//+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))
+func (iter *Iterator) skipArray() {
+	level := 1
+	if !iter.incrementDepth() {
 		return
 	}
+	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++
+				if !iter.incrementDepth() {
+					return
+				}
+			case ']': // If close symbol, increase level
+				level--
+				if !iter.decrementDepth() {
+					return
+				}
+
+				// 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
+	if !iter.incrementDepth() {
+		return
+	}
+
+	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++
+				if !iter.incrementDepth() {
+					return
+				}
+			case '}': // If close symbol, increase level
+				level--
+				if !iter.decrementDepth() {
+					return
+				}
+
+				// 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) skipString() {
@@ -152,89 +161,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,99 @@
+//+build !jsoniter_sloppy
+
+package jsoniter
+
+import (
+	"fmt"
+	"io"
+)
+
+func (iter *Iterator) skipNumber() {
+	if !iter.trySkipNumber() {
+		iter.unreadByte()
+		if iter.Error != nil && iter.Error != io.EOF {
+			return
+		}
+		iter.ReadFloat64()
+		if iter.Error != nil && iter.Error != io.EOF {
+			iter.Error = nil
+			iter.ReadBigFloat()
+		}
+	}
+}
+
+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)
-	}
-}