Merge branch 'master' of https://github.com/json-iterator/go

.idea/libraries/Go_SDK.xml

@@ -0,0 +1,10 @@
+<component name="libraryTable">
+  <library name="Go SDK">
+    <CLASSES>
+      <root url="file:///usr/local/go/src" />
+    </CLASSES>
+    <SOURCES>
+      <root url="file:///usr/local/go/src" />
+    </SOURCES>
+  </library>
+</component>

feature_adapter.go

@@ -1,3 +1,14 @@
+// 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 (
@@ -34,6 +45,7 @@ func Unmarshal(data []byte, v interface{}) error {
 	return iter.Error
 }
 
+// UnmarshalAny adapts to
 func UnmarshalAny(data []byte) (Any, error) {
 	data = data[:lastNotSpacePos(data)]
 	iter := ParseBytes(data)

feature_iter.go

@@ -1,3 +1,9 @@
+//
+// 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 (

feature_reflect.go

@@ -9,19 +9,23 @@ import (
 	"unsafe"
 )
 
-/*
-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
-*/
-
+// Decoder is an internal type registered to cache as needed.
+// Don't confuse jsoniter.Decoder 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 Decoder interface {
 	decode(ptr unsafe.Pointer, iter *Iterator)
 }
 
+// Encoder is an internal type registered to cache as needed.
+// Don't confuse jsoniter.Encoder with json.Encoder.
+// For json.Encoder's adapter, refer to jsoniter.AdapterEncoder(todo godoc link).
 type Encoder interface {
 	isEmpty(ptr unsafe.Pointer) bool
 	encode(ptr unsafe.Pointer, stream *Stream)
@@ -166,7 +170,7 @@ func CleanDecoders() {
 	atomic.StorePointer(&DECODERS, unsafe.Pointer(&map[string]Decoder{}))
 }
 
-// CleanEncoders cleans decoders registered or cached
+// CleanEncoders cleans encoders registered or cached
 func CleanEncoders() {
 	typeEncoders = map[string]Encoder{}
 	fieldEncoders = map[string]Encoder{}

feature_stream_float.go

@@ -75,6 +75,8 @@ func (stream *Stream) WriteFloat64Lossy(val float64) {
 	}
 }
 
+// EnableLossyFloatMarshalling keeps 10**(-6) precision
+// for float variables for better performance.
 func EnableLossyFloatMarshalling() {
 	// for better performance
 	RegisterTypeEncoder("float32", func(ptr unsafe.Pointer, stream *Stream) {