implement ReadInterface

Author: Tao Wen

iter.go

@@ -4,34 +4,14 @@ import (
 	"fmt"
 )
 
-// ValueType the type for JSON element
-type ValueType int
-
 type RawMessage []byte
 
-const (
-	// InvalidValue invalid JSON element
-	InvalidValue ValueType = iota
-	// StringValue JSON element "string"
-	StringValue
-	// NumberValue JSON element 100 or 0.10
-	NumberValue
-	// NullValue JSON element null
-	NullValue
-	// BoolValue JSON element true or false
-	BoolValue
-	// ArrayValue JSON element []
-	ArrayValue
-	// ObjectValue JSON element {}
-	ObjectValue
-)
 const uint32SafeToMultiply10 = uint32(0xffffffff)/10 - 1
 const uint64SafeToMultiple10 = uint64(0xffffffffffffffff)/10 - 1
 const maxFloat64 = 1<<53 - 1
 
 var pow10 []uint64
 var hexDigits []byte
-var valueTypes []ValueType
 
 func init() {
 	pow10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
@@ -48,27 +28,6 @@ func init() {
 	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'] = NullValue
-	valueTypes['['] = ArrayValue
-	valueTypes['{'] = ObjectValue
 }
 
 // Iterator is a io.Reader like object, with JSON specific read functions.
@@ -87,13 +46,6 @@ func ParseBytes(input []byte) *Iterator {
 	}
 }
 
-// WhatIsNext gets ValueType of relatively next json element
-func (iter *Iterator) WhatIsNext() ValueType {
-	valueType := valueTypes[iter.nextToken()]
-	iter.unreadByte()
-	return valueType
-}
-
 func (iter *Iterator) skipWhitespaces() {
 	for i := iter.head; i < len(iter.buf); i++ {
 		c := iter.buf[i]
@@ -107,18 +59,6 @@ func (iter *Iterator) skipWhitespaces() {
 	iter.head = len(iter.buf)
 }
 
-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
-}
-
 // ReportError record a error in iterator instance with current position.
 func (iter *Iterator) ReportError(operation string, msg string) error {
 	if iter.Error != nil {

iter_interface.go

@@ -0,0 +1,76 @@
+package jsoniter
+
+import (
+	"fmt"
+)
+
+func (iter *Iterator) ReadInterface(out *interface{}) (ret error) {
+	c := iter.nextToken()
+	switch c {
+	case '"':
+		var val string
+		ret = iter.readString(&val)
+		if ret == nil {
+			*out = val
+		}
+		return
+	case 'n':
+		return iter.skipThreeBytes('u', 'l', 'l') // null
+	case 't':
+		ret = iter.skipThreeBytes('r', 'u', 'e') // true
+		if ret == nil {
+			*out = true
+		}
+		return
+	case 'f':
+		ret = iter.skipFourBytes('a', 'l', 's', 'e') // false
+		if ret == nil {
+			*out = false
+		}
+		return
+	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		iter.unreadByte()
+		var val float64
+		ret = iter.ReadFloat64(&val)
+		if ret == nil {
+			*out = val
+		}
+		return
+	case '[':
+		var val = make([]interface{}, 0)
+		c := iter.nextToken()
+		if c == ']' {
+			*out = val
+			return
+		}
+		iter.unreadByte()
+		more := true
+		for more {
+			var elem interface{}
+			iter.ReadInterface(&elem)
+			val = append(val, elem)
+			more = iter.ReadArrayMore()
+		}
+		*out = val
+		return iter.Error
+	case '{':
+		val := make(map[string]interface{}, 0)
+		*out = val
+		c := iter.nextToken()
+		if c == ']' {
+			return
+		}
+		iter.unreadByte()
+		more := true
+		for more {
+			k := iter.ReadObjectField()
+			var v interface{}
+			iter.ReadInterface(&v)
+			val[k] = v
+			more = iter.ReadObjectMore()
+		}
+		return iter.Error
+	default:
+		return iter.ReportError("ReadInterface", fmt.Sprintf("unexpected character: %v", c))
+	}
+}

iter_str.go

@@ -17,6 +17,10 @@ func (iter *Iterator) ReadString(out *string) error {
 		iter.skip(c)
 		return err
 	}
+	return iter.readString(out)
+}
+
+func (iter *Iterator) readString(out *string) error {
 	for i := iter.head; i < len(iter.buf); i++ {
 		c := iter.buf[i]
 		if c == '"' {

iter_tests/interface_test.go

@@ -0,0 +1,51 @@
+package iter_tests
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	jsoniter "github.com/json-iterator/tinygo"
+)
+
+func readEmptyInterface(input string, expectedValue interface{}) {
+	iter := jsoniter.ParseBytes([]byte(input))
+	var val interface{}
+	iter.ReadInterface(&val)
+	if val != expectedValue {
+		panic(fmt.Errorf("expect %s, acutal %s", expectedValue, val))
+	}
+}
+
+func Test_read_empty_interface(t *testing.T) {
+	readEmptyInterface("true", true)
+	readEmptyInterface("false", false)
+	readEmptyInterface("100", float64(100))
+	readEmptyInterface(`"hello"`, "hello")
+}
+
+func Test_read_array_as_empty_interface(t *testing.T) {
+	iter := jsoniter.ParseBytes([]byte(`[1,true,"hello"]`))
+	var val interface{}
+	iter.ReadInterface(&val)
+	bytes, err := json.Marshal(val)
+	if err != nil {
+		t.Fatal()
+	}
+	if string(bytes) != `[1,true,"hello"]` {
+		t.Fatal()
+	}
+}
+
+func Test_read_object_as_empty_interface(t *testing.T) {
+	iter := jsoniter.ParseBytes([]byte(`{"hello":"world"}`))
+	var val interface{}
+	iter.ReadInterface(&val)
+	bytes, err := json.Marshal(val)
+	if err != nil {
+		t.Fatal()
+	}
+	if string(bytes) != `{"hello":"world"}` {
+		t.Fatal()
+	}
+}