jsoniter.go

package jsoniter

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"reflect"
	"strconv"
	"strings"
	"sync/atomic"
)

// Encoder 与标准库保持兼容，直接复用 encoding/json.Encoder。
type Encoder = json.Encoder

// Decoder 与标准库保持兼容，直接复用 encoding/json.Decoder。
type Decoder = json.Decoder

// Config 对齐 jsoniter 的常用配置字段，作为迁移期兼容层使用。
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 提供 jsoniter 常用序列化/反序列化入口。
type API interface {
	Marshal(v interface{}) ([]byte, error)
	MarshalToString(v interface{}) (string, error)
	MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
	Unmarshal(data []byte, v interface{}) error
	UnmarshalFromString(str string, v interface{}) error
	NewEncoder(writer io.Writer) *Encoder
	NewDecoder(reader io.Reader) *Decoder
	Valid(data []byte) bool
}

var fuzzyDecoderEnabled uint32

type frozenConfig struct {
	cfg Config
}

var (
	ConfigDefault API = Config{
		EscapeHTML: true,
	}.Froze()

	ConfigCompatibleWithStandardLibrary API = Config{
		EscapeHTML:             true,
		SortMapKeys:            true,
		ValidateJsonRawMessage: true,
	}.Froze()

	ConfigFastest API = Config{
		EscapeHTML:                    false,
		MarshalFloatWith6Digits:       true,
		ObjectFieldMustBeSimpleString: true,
	}.Froze()
)

func (cfg Config) Froze() API {
	return &frozenConfig{cfg: cfg}
}

func Marshal(v interface{}) ([]byte, error) {
	return ConfigDefault.Marshal(v)
}

func MarshalToString(v interface{}) (string, error) {
	return ConfigDefault.MarshalToString(v)
}

func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
	return ConfigDefault.MarshalIndent(v, prefix, indent)
}

func Unmarshal(data []byte, v interface{}) error {
	return ConfigDefault.Unmarshal(data, v)
}

func UnmarshalFromString(str string, v interface{}) error {
	return ConfigDefault.UnmarshalFromString(str, v)
}

func NewEncoder(writer io.Writer) *Encoder {
	return ConfigDefault.NewEncoder(writer)
}

func NewDecoder(reader io.Reader) *Decoder {
	return ConfigDefault.NewDecoder(reader)
}

func Valid(data []byte) bool {
	return ConfigDefault.Valid(data)
}

// EnableFuzzyDecoders 由 extra.RegisterFuzzyDecoders 调用。
func EnableFuzzyDecoders() {
	atomic.StoreUint32(&fuzzyDecoderEnabled, 1)
}

// DisableFuzzyDecoders 便于测试或迁移期兜底回滚。
func DisableFuzzyDecoders() {
	atomic.StoreUint32(&fuzzyDecoderEnabled, 0)
}

func (c *frozenConfig) Marshal(v interface{}) ([]byte, error) {
	return marshalWithConfig(c.cfg, v)
}

func (c *frozenConfig) MarshalToString(v interface{}) (string, error) {
	data, err := c.Marshal(v)
	if err != nil {
		return "", err
	}
	return string(data), nil
}

func (c *frozenConfig) MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
	if c.cfg.EscapeHTML {
		return json.MarshalIndent(v, prefix, indent)
	}

	var buf bytes.Buffer
	enc := json.NewEncoder(&buf)
	enc.SetEscapeHTML(false)
	enc.SetIndent(prefix, indent)
	if err := enc.Encode(v); err != nil {
		return nil, err
	}
	out := buf.Bytes()
	if len(out) > 0 && out[len(out)-1] == '\n' {
		out = out[:len(out)-1]
	}
	return out, nil
}

func (c *frozenConfig) Unmarshal(data []byte, v interface{}) error {
	return unmarshalWithConfig(c.cfg, data, v)
}

func (c *frozenConfig) UnmarshalFromString(str string, v interface{}) error {
	return c.Unmarshal([]byte(str), v)
}

func (c *frozenConfig) NewEncoder(writer io.Writer) *Encoder {
	enc := json.NewEncoder(writer)
	enc.SetEscapeHTML(c.cfg.EscapeHTML)
	if c.cfg.IndentionStep > 0 {
		enc.SetIndent("", strings.Repeat(" ", c.cfg.IndentionStep))
	}
	return enc
}

func (c *frozenConfig) NewDecoder(reader io.Reader) *Decoder {
	dec := json.NewDecoder(reader)
	if c.cfg.UseNumber {
		dec.UseNumber()
	}
	if c.cfg.DisallowUnknownFields {
		dec.DisallowUnknownFields()
	}
	return dec
}

func (c *frozenConfig) Valid(data []byte) bool {
	return json.Valid(data)
}

func marshalWithConfig(cfg Config, v interface{}) ([]byte, error) {
	if cfg.EscapeHTML {
		return json.Marshal(v)
	}

	var buf bytes.Buffer
	enc := json.NewEncoder(&buf)
	enc.SetEscapeHTML(false)
	if err := enc.Encode(v); err != nil {
		return nil, err
	}
	out := buf.Bytes()
	if len(out) > 0 && out[len(out)-1] == '\n' {
		out = out[:len(out)-1]
	}
	return out, nil
}

func unmarshalWithConfig(cfg Config, data []byte, v interface{}) error {
	if v == nil {
		return &json.InvalidUnmarshalError{Type: nil}
	}
	target := reflect.ValueOf(v)
	if target.Kind() != reflect.Ptr || target.IsNil() {
		return &json.InvalidUnmarshalError{Type: target.Type()}
	}

	if atomic.LoadUint32(&fuzzyDecoderEnabled) == 0 {
		return decodeStrict(cfg, data, v)
	}

	if err := decodeStrict(cfg, data, v); err == nil {
		return nil
	}

	var raw interface{}
	dec := json.NewDecoder(bytes.NewReader(data))
	dec.UseNumber()
	if err := dec.Decode(&raw); err != nil {
		return err
	}
	if err := ensureEOF(dec); err != nil {
		return err
	}

	if err := fuzzyAssign(target.Elem(), raw, cfg); err != nil {
		return err
	}
	return nil
}

func decodeStrict(cfg Config, data []byte, v interface{}) error {
	dec := json.NewDecoder(bytes.NewReader(data))
	if cfg.UseNumber {
		dec.UseNumber()
	}
	if cfg.DisallowUnknownFields {
		dec.DisallowUnknownFields()
	}
	if err := dec.Decode(v); err != nil {
		return err
	}
	return ensureEOF(dec)
}

func ensureEOF(dec *json.Decoder) error {
	var trailing interface{}
	err := dec.Decode(&trailing)
	if err == io.EOF {
		return nil
	}
	if err != nil {
		return err
	}
	return fmt.Errorf("invalid character after top-level value")
}

func fuzzyAssign(dst reflect.Value, src interface{}, cfg Config) error {
	if !dst.IsValid() {
		return fmt.Errorf("invalid destination")
	}

	if src == nil {
		switch dst.Kind() {
		case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
			dst.Set(reflect.Zero(dst.Type()))
		}
		return nil
	}

	if dst.CanAddr() {
		if unmarshaler, ok := dst.Addr().Interface().(json.Unmarshaler); ok {
			payload, err := json.Marshal(src)
			if err != nil {
				return err
			}
			return unmarshaler.UnmarshalJSON(payload)
		}
	}

	if dst.Kind() == reflect.Ptr {
		if dst.IsNil() {
			dst.Set(reflect.New(dst.Type().Elem()))
		}
		return fuzzyAssign(dst.Elem(), src, cfg)
	}

	switch dst.Kind() {
	case reflect.Interface:
		dst.Set(reflect.ValueOf(normalizeGenericValue(src)))
		return nil
	case reflect.Bool:
		val, err := toBool(src)
		if err != nil {
			return err
		}
		dst.SetBool(val)
		return nil
	case reflect.String:
		dst.SetString(toString(src))
		return nil
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		val, err := toInt64(src)
		if err != nil {
			return err
		}
		if dst.OverflowInt(val) {
			return fmt.Errorf("value %d overflows %s", val, dst.Type())
		}
		dst.SetInt(val)
		return nil
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		val, err := toUint64(src)
		if err != nil {
			return err
		}
		if dst.OverflowUint(val) {
			return fmt.Errorf("value %d overflows %s", val, dst.Type())
		}
		dst.SetUint(val)
		return nil
	case reflect.Float32, reflect.Float64:
		val, err := toFloat64(src)
		if err != nil {
			return err
		}
		if dst.OverflowFloat(val) {
			return fmt.Errorf("value %f overflows %s", val, dst.Type())
		}
		dst.SetFloat(val)
		return nil
	case reflect.Struct:
		srcMap, ok := src.(map[string]interface{})
		if !ok {
			payload, err := json.Marshal(src)
			if err != nil {
				return err
			}
			return json.Unmarshal(payload, dst.Addr().Interface())
		}
		return assignStruct(dst, srcMap, cfg)
	case reflect.Map:
		srcMap, ok := src.(map[string]interface{})
		if !ok {
			return fmt.Errorf("expected object for %s, got %T", dst.Type(), src)
		}
		if dst.IsNil() {
			dst.Set(reflect.MakeMap(dst.Type()))
		}
		for k, rawVal := range srcMap {
			mapKey, err := convertMapKey(k, dst.Type().Key())
			if err != nil {
				return err
			}
			elem := reflect.New(dst.Type().Elem()).Elem()
			if err := fuzzyAssign(elem, rawVal, cfg); err != nil {
				return err
			}
			dst.SetMapIndex(mapKey, elem)
		}
		return nil
	case reflect.Slice:
		srcSlice, ok := src.([]interface{})
		if !ok {
			return fmt.Errorf("expected array for %s, got %T", dst.Type(), src)
		}
		slice := reflect.MakeSlice(dst.Type(), len(srcSlice), len(srcSlice))
		for i := range srcSlice {
			if err := fuzzyAssign(slice.Index(i), srcSlice[i], cfg); err != nil {
				return err
			}
		}
		dst.Set(slice)
		return nil
	case reflect.Array:
		srcSlice, ok := src.([]interface{})
		if !ok {
			return fmt.Errorf("expected array for %s, got %T", dst.Type(), src)
		}
		for i := 0; i < dst.Len() && i < len(srcSlice); i++ {
			if err := fuzzyAssign(dst.Index(i), srcSlice[i], cfg); err != nil {
				return err
			}
		}
		return nil
	default:
		payload, err := json.Marshal(src)
		if err != nil {
			return err
		}
		return json.Unmarshal(payload, dst.Addr().Interface())
	}
}

func assignStruct(dst reflect.Value, src map[string]interface{}, cfg Config) error {
	fieldIndex := make(map[string]int, dst.NumField())
	t := dst.Type()

	for i := 0; i < dst.NumField(); i++ {
		field := t.Field(i)
		if field.PkgPath != "" {
			continue
		}
		name, tagged := jsonFieldName(field, cfg.TagKey)
		if name == "-" {
			continue
		}
		if cfg.OnlyTaggedField && !tagged {
			continue
		}
		fieldIndex[name] = i
	}

	for key, rawVal := range src {
		index, ok := fieldIndex[key]
		if !ok && !cfg.CaseSensitive {
			for candidate, idx := range fieldIndex {
				if strings.EqualFold(candidate, key) {
					index = idx
					ok = true
					break
				}
			}
		}
		if !ok {
			if cfg.DisallowUnknownFields {
				return fmt.Errorf("json: unknown field %q", key)
			}
			continue
		}

		fieldVal := dst.Field(index)
		if !fieldVal.CanSet() {
			continue
		}
		if err := fuzzyAssign(fieldVal, rawVal, cfg); err != nil {
			return fmt.Errorf("field %s: %w", t.Field(index).Name, err)
		}
	}

	return nil
}

func jsonFieldName(field reflect.StructField, tagKey string) (name string, tagged bool) {
	if tagKey == "" {
		tagKey = "json"
	}
	tag := field.Tag.Get(tagKey)
	if tag == "-" {
		return "-", true
	}
	if tag == "" {
		return field.Name, false
	}
	name = strings.Split(tag, ",")[0]
	if name == "" {
		return field.Name, true
	}
	return name, true
}

func convertMapKey(raw string, target reflect.Type) (reflect.Value, error) {
	switch target.Kind() {
	case reflect.String:
		return reflect.ValueOf(raw).Convert(target), nil
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		v, err := strconv.ParseInt(strings.TrimSpace(raw), 10, 64)
		if err != nil {
			return reflect.Value{}, err
		}
		key := reflect.New(target).Elem()
		if key.OverflowInt(v) {
			return reflect.Value{}, fmt.Errorf("value %d overflows %s", v, target)
		}
		key.SetInt(v)
		return key, nil
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		v, err := strconv.ParseUint(strings.TrimSpace(raw), 10, 64)
		if err != nil {
			return reflect.Value{}, err
		}
		key := reflect.New(target).Elem()
		if key.OverflowUint(v) {
			return reflect.Value{}, fmt.Errorf("value %d overflows %s", v, target)
		}
		key.SetUint(v)
		return key, nil
	default:
		return reflect.Value{}, fmt.Errorf("unsupported map key type: %s", target)
	}
}

func toBool(src interface{}) (bool, error) {
	switch v := src.(type) {
	case bool:
		return v, nil
	case string:
		s := strings.TrimSpace(v)
		if s == "" {
			return false, nil
		}
		if b, err := strconv.ParseBool(s); err == nil {
			return b, nil
		}
		f, err := strconv.ParseFloat(s, 64)
		if err != nil {
			return false, err
		}
		return f != 0, nil
	case json.Number:
		f, err := v.Float64()
		if err != nil {
			return false, err
		}
		return f != 0, nil
	case float64:
		return v != 0, nil
	case float32:
		return v != 0, nil
	case int:
		return v != 0, nil
	case int8:
		return v != 0, nil
	case int16:
		return v != 0, nil
	case int32:
		return v != 0, nil
	case int64:
		return v != 0, nil
	case uint:
		return v != 0, nil
	case uint8:
		return v != 0, nil
	case uint16:
		return v != 0, nil
	case uint32:
		return v != 0, nil
	case uint64:
		return v != 0, nil
	default:
		return false, fmt.Errorf("cannot convert %T to bool", src)
	}
}

func toInt64(src interface{}) (int64, error) {
	switch v := src.(type) {
	case int64:
		return v, nil
	case int:
		return int64(v), nil
	case int8:
		return int64(v), nil
	case int16:
		return int64(v), nil
	case int32:
		return int64(v), nil
	case uint:
		return int64(v), nil
	case uint8:
		return int64(v), nil
	case uint16:
		return int64(v), nil
	case uint32:
		return int64(v), nil
	case uint64:
		if v > uint64(^uint64(0)>>1) {
			return 0, fmt.Errorf("value %d overflows int64", v)
		}
		return int64(v), nil
	case float64:
		return int64(v), nil
	case float32:
		return int64(v), nil
	case bool:
		if v {
			return 1, nil
		}
		return 0, nil
	case string:
		s := strings.TrimSpace(v)
		if s == "" {
			return 0, nil
		}
		if i, err := strconv.ParseInt(s, 10, 64); err == nil {
			return i, nil
		}
		f, err := strconv.ParseFloat(s, 64)
		if err != nil {
			return 0, err
		}
		return int64(f), nil
	case json.Number:
		if i, err := v.Int64(); err == nil {
			return i, nil
		}
		f, err := v.Float64()
		if err != nil {
			return 0, err
		}
		return int64(f), nil
	default:
		return 0, fmt.Errorf("cannot convert %T to int64", src)
	}
}

func toUint64(src interface{}) (uint64, error) {
	switch v := src.(type) {
	case uint64:
		return v, nil
	case uint:
		return uint64(v), nil
	case uint8:
		return uint64(v), nil
	case uint16:
		return uint64(v), nil
	case uint32:
		return uint64(v), nil
	case int:
		if v < 0 {
			return 0, fmt.Errorf("negative value %d cannot convert to uint64", v)
		}
		return uint64(v), nil
	case int8:
		if v < 0 {
			return 0, fmt.Errorf("negative value %d cannot convert to uint64", v)
		}
		return uint64(v), nil
	case int16:
		if v < 0 {
			return 0, fmt.Errorf("negative value %d cannot convert to uint64", v)
		}
		return uint64(v), nil
	case int32:
		if v < 0 {
			return 0, fmt.Errorf("negative value %d cannot convert to uint64", v)
		}
		return uint64(v), nil
	case int64:
		if v < 0 {
			return 0, fmt.Errorf("negative value %d cannot convert to uint64", v)
		}
		return uint64(v), nil
	case float64:
		if v < 0 {
			return 0, fmt.Errorf("negative value %f cannot convert to uint64", v)
		}
		return uint64(v), nil
	case float32:
		if v < 0 {
			return 0, fmt.Errorf("negative value %f cannot convert to uint64", v)
		}
		return uint64(v), nil
	case bool:
		if v {
			return 1, nil
		}
		return 0, nil
	case string:
		s := strings.TrimSpace(v)
		if s == "" {
			return 0, nil
		}
		if u, err := strconv.ParseUint(s, 10, 64); err == nil {
			return u, nil
		}
		f, err := strconv.ParseFloat(s, 64)
		if err != nil {
			return 0, err
		}
		if f < 0 {
			return 0, fmt.Errorf("negative value %f cannot convert to uint64", f)
		}
		return uint64(f), nil
	case json.Number:
		if i, err := v.Int64(); err == nil {
			if i < 0 {
				return 0, fmt.Errorf("negative value %d cannot convert to uint64", i)
			}
			return uint64(i), nil
		}
		f, err := v.Float64()
		if err != nil {
			return 0, err
		}
		if f < 0 {
			return 0, fmt.Errorf("negative value %f cannot convert to uint64", f)
		}
		return uint64(f), nil
	default:
		return 0, fmt.Errorf("cannot convert %T to uint64", src)
	}
}

func toFloat64(src interface{}) (float64, error) {
	switch v := src.(type) {
	case float64:
		return v, nil
	case float32:
		return float64(v), nil
	case int:
		return float64(v), nil
	case int8:
		return float64(v), nil
	case int16:
		return float64(v), nil
	case int32:
		return float64(v), nil
	case int64:
		return float64(v), nil
	case uint:
		return float64(v), nil
	case uint8:
		return float64(v), nil
	case uint16:
		return float64(v), nil
	case uint32:
		return float64(v), nil
	case uint64:
		return float64(v), nil
	case bool:
		if v {
			return 1, nil
		}
		return 0, nil
	case string:
		s := strings.TrimSpace(v)
		if s == "" {
			return 0, nil
		}
		return strconv.ParseFloat(s, 64)
	case json.Number:
		return v.Float64()
	default:
		return 0, fmt.Errorf("cannot convert %T to float64", src)
	}
}

func toString(src interface{}) string {
	switch v := src.(type) {
	case string:
		return v
	case json.Number:
		return v.String()
	case nil:
		return ""
	default:
		return fmt.Sprint(v)
	}
}

func normalizeGenericValue(v interface{}) interface{} {
	switch val := v.(type) {
	case map[string]interface{}:
		out := make(map[string]interface{}, len(val))
		for k, v := range val {
			out[k] = normalizeGenericValue(v)
		}
		return out
	case []interface{}:
		out := make([]interface{}, len(val))
		for i := range val {
			out[i] = normalizeGenericValue(val[i])
		}
		return out
	case json.Number:
		if i, err := val.Int64(); err == nil {
			return i
		}
		if f, err := val.Float64(); err == nil {
			return f
		}
		return val.String()
	default:
		return val
	}
}

// 兼容历史工具函数。
func JsoniterUnmarshal(data []byte, target interface{}) error {
	return Unmarshal(data, target)
}

// 兼容历史工具函数。
func JsoniterMarshalToString(v interface{}) string {
	out, err := MarshalToString(v)
	if err != nil {
		return ""
	}
	return out
}