object.go

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package hessian

import (
	"io"
	"reflect"
	"strings"
	"sync"
)

import (
	perrors "github.com/pkg/errors"
)

// get @v go struct name
func typeof(v interface{}) string {
	return reflect.TypeOf(v).String()
}

/////////////////////////////////////////
// map/object
/////////////////////////////////////////

// class-def  ::= 'C' string int string* //  mandatory type string, the number of fields, and the field names.
// object     ::= 'O' int value* // class-def id, value list
//
//	::= [x60-x6f] value* // class-def id, value list
//
// # Object serialization
//
//	class Car {
//	  String color;
//	  String model;
//	}
//
// out.writeObject(new Car("red", "corvette"));
// out.writeObject(new Car("green", "civic"));
//
// ---
//
// C                        # object definition (#0)
//
//	x0b example.Car        # type is example.Car
//	x92                    # two fields
//	x05 color              # color field name
//	x05 model              # model field name
//
// O                        # object def (long form)
//
//	x90                    # object definition #0
//	x03 red                # color field value
//	x08 corvette           # model field value
//
// x60                      # object def #0 (short form)
//
//	x05 green              # color field value
//	x05 civic              # model field value
//
//	enum Color {
//	  RED,
//	  GREEN,
//	  BLUE,
//	}
//
// out.writeObject(Color.RED);
// out.writeObject(Color.GREEN);
// out.writeObject(Color.BLUE);
// out.writeObject(Color.GREEN);
//
// ---
//
// C                         # class definition #0
//
//	x0b example.Color       # type is example.Color
//	x91                     # one field
//	x04 name                # enumeration field is "name"
//
// x60                       # object #0 (class def #0)
//
//	x03 RED                 # RED value
//
// x60                       # object #1 (class def #0)
//
//	x90                     # object definition ref #0
//	x05 GREEN               # GREEN value
//
// x60                       # object #2 (class def #0)
//
//	x04 BLUE                # BLUE value
//
// x51 x91                   # object ref #1, i.e. Color.GREEN
func (e *Encoder) encObject(v interface{}) error {
	var (
		i      int
		idx    int
		num    int
		err    error
		clsDef *ClassInfo
	)
	pojo, isPojo := v.(POJO)
	// get none pojo JavaClassName
	var nonePojoJavaName string
	if !isPojo {
		s, ok := loadPOJORegistry(v)
		if !ok {
			return perrors.Errorf("non-pojo obj %s has not being registered before!", typeof(v))
		}
		nonePojoJavaName = s.javaName
	}

	vv := reflect.ValueOf(v)
	// check ref
	if n, ok := e.checkRefMap(vv); ok {
		e.buffer = encRef(e.buffer, n)
		return nil
	}

	vv = UnpackPtr(vv)
	// check nil pointer
	if !vv.IsValid() {
		e.buffer = EncNull(e.buffer)
		return nil
	}

	// write object definition
	idx = -1
	for i = range e.classInfoList {
		if isPojo && pojo.JavaClassName() == e.classInfoList[i].javaName || !isPojo && nonePojoJavaName == e.classInfoList[i].javaName {
			idx = i
			break
		}
	}

	var ok bool
	if idx == -1 {
		idx, ok = checkPOJORegistry(v)
		if !ok {
			if reflect.TypeOf(v).Implements(javaEnumType) {
				idx = RegisterJavaEnum(v.(POJOEnum))
			} else if isPojo {
				idx = RegisterPOJO(pojo)
			} else {
				return perrors.Errorf("non-pojo obj %s has not being registered before!", typeof(v))
			}
		}
		_, clsDef, err = getStructDefByIndex(idx)
		if err != nil {
			return perrors.WithStack(err)
		}

		idx = len(e.classInfoList)
		e.classInfoList = append(e.classInfoList, clsDef)
		e.buffer = append(e.buffer, clsDef.buffer...)
	}

	// write object instance
	if byte(idx) <= OBJECT_DIRECT_MAX {
		e.buffer = encByte(e.buffer, byte(idx)+BC_OBJECT_DIRECT)
	} else {
		e.buffer = encByte(e.buffer, BC_OBJECT)
		e.buffer = encInt32(e.buffer, int32(idx))
	}

	if reflect.TypeOf(v).Implements(javaEnumType) {
		e.buffer = encString(e.buffer, v.(POJOEnum).String())
		return nil
	}

	structs := []reflect.Value{vv}
	for len(structs) > 0 {
		vv := structs[0]
		vvt := vv.Type()
		num = vv.NumField()
		for i = 0; i < num; i++ {
			tf := vvt.Field(i)
			// skip unexported anonymous field
			if tf.PkgPath != "" {
				continue
			}

			// skip ignored field
			if tag, _ := tf.Tag.Lookup(tagIdentifier); tag == `-` {
				continue
			}

			field := vv.Field(i)
			if tf.Anonymous && field.Kind() == reflect.Struct {
				structs = append(structs, field)
				continue
			}

			if err = e.Encode(field.Interface()); err != nil {
				fieldName := field.Type().String()
				return perrors.Wrapf(err, "failed to encode field: %s, %+v", fieldName, field.Interface())
			}
		}

		structs = structs[1:]
	}

	return nil
}

// EncodeMapClass encode a map as object, which MUST contains a key _class and its value is the target class name.
func (e *Encoder) EncodeMapClass(m map[string]interface{}) error {
	clsName, ok := m[ClassKey]
	if !ok {
		return perrors.New("no _class key map")
	}

	className, ok := clsName.(string)
	if !ok {
		return perrors.Errorf("expect string class name, but get %v", reflect.TypeOf(clsName))
	}

	return e.EncodeMapAsClass(className, m)
}

// EncodeMapAsClass encode a map as object of given class name.
func (e *Encoder) EncodeMapAsClass(className string, m map[string]interface{}) error {
	idx := e.classIndex(className)

	if idx == -1 {
		var clsDef *ClassInfo
		s, ok := getStructInfo(className)
		if ok {
			clsDef = pojoRegistry.classInfoList[s.index]
		} else {
			var err error
			clsDef, err = buildMapClassDef(className, m)
			if err != nil {
				return err
			}
		}
		idx = len(e.classInfoList)
		e.classInfoList = append(e.classInfoList, clsDef)
		e.buffer = append(e.buffer, clsDef.buffer...)
	}

	return e.encodeMapAsIndexedClass(idx, m)
}

// EncodeMapAsObject encode a map as the given class defined object.
// Sometimes a class may not being registered in hessian, but it can be decoded from serialized data,
// and the ClassInfo can be found in Decoder by calling Decoder.FindClassInfo.
func (e *Encoder) EncodeMapAsObject(clsDef *ClassInfo, m map[string]interface{}) error {
	idx := e.classIndex(clsDef.javaName)
	if idx == -1 {
		idx = len(e.classInfoList)
		e.classInfoList = append(e.classInfoList, clsDef)
		if len(clsDef.buffer) == 0 {
			clsDef.initDefBuffer()
		}
		e.buffer = append(e.buffer, clsDef.buffer...)
	}
	return e.encodeMapAsIndexedClass(idx, m)
}

// encodeMapAsIndexedClass encode a map as the defined class at the given index in the encoder class list.
func (e *Encoder) encodeMapAsIndexedClass(idx int, m map[string]interface{}) error {
	// write object instance
	if byte(idx) <= OBJECT_DIRECT_MAX {
		e.buffer = encByte(e.buffer, byte(idx)+BC_OBJECT_DIRECT)
	} else {
		e.buffer = encByte(e.buffer, BC_OBJECT)
		e.buffer = encInt32(e.buffer, int32(idx))
	}

	cls := e.classInfoList[idx]
	var err error
	for i := 0; i < len(cls.fieldNameList); i++ {
		fieldName := cls.fieldNameList[i]
		if err = e.Encode(m[fieldName]); err != nil {
			return perrors.Wrapf(err, "failed to encode field: %s, %+v", fieldName, m[fieldName])
		}
	}
	return nil
}

/////////////////////////////////////////
// Object
/////////////////////////////////////////

// class-def  ::= 'C' string int string* //  mandatory type string, the number of fields, and the field names.
// object     ::= 'O' int value* // class-def id, value list
//            ::= [x60-x6f] value* // class-def id, value list
//
// Object serialization
//
// class Car {
//   String color;
//   String model;
// }
//
// out.writeObject(new Car("red", "corvette"));
// out.writeObject(new Car("green", "civic"));
//
// ---
//
// C                        # object definition (#0)
//   x0b example.Car        # type is example.Car
//   x92                    # two fields
//   x05 color              # color field name
//   x05 model              # model field name
//
// O                        # object def (long form)
//   x90                    # object definition #0
//   x03 red                # color field value
//   x08 corvette           # model field value
//
// x60                      # object def #0 (short form)
//   x05 green              # color field value
//   x05 civic              # model field value
//
//
//
//
//
// enum Color {
//   RED,
//   GREEN,
//   BLUE,
// }
//
// out.writeObject(Color.RED);
// out.writeObject(Color.GREEN);
// out.writeObject(Color.BLUE);
// out.writeObject(Color.GREEN);
//
// ---
//
// C                         # class definition #0
//   x0b example.Color       # type is example.Color
//   x91                     # one field
//   x04 name                # enumeration field is "name"
//
// x60                       # object #0 (class def #0)
//   x03 RED                 # RED value
//
// x60                       # object #1 (class def #0)
//   x90                     # object definition ref #0
//   x05 GREEN               # GREEN value
//
// x60                       # object #2 (class def #0)
//   x04 BLUE                # BLUE value
//
// x51 x91                   # object ref #1, i.e. Color.GREEN

func (d *Decoder) decClassDef() (interface{}, error) {
	var (
		err       error
		clsName   string
		fieldNum  int32
		fieldName string
		fieldList []string
	)

	clsName, err = d.decString(TAG_READ)
	if err != nil {
		return nil, perrors.WithStack(err)
	}
	fieldNum, err = d.decInt32(TAG_READ)
	if err != nil {
		return nil, perrors.WithStack(err)
	}
	fieldList = make([]string, fieldNum)
	for i := 0; i < int(fieldNum); i++ {
		fieldName, err = d.decString(TAG_READ)
		if err != nil {
			return nil, perrors.Wrapf(err, "decClassDef->decString, field num:%d, index:%d", fieldNum, i)
		}
		fieldList[i] = fieldName
	}

	return &ClassInfo{javaName: clsName, fieldNameList: fieldList}, nil
}

type fieldInfo struct {
	indexes []int
	field   *reflect.StructField
}

// map[rType][fieldName]indexes
var fieldIndexCache sync.Map

func findFieldWithCache(name string, typ reflect.Type) ([]int, *reflect.StructField, error) {
	typCache, _ := fieldIndexCache.Load(typ)
	if typCache == nil {
		typCache = &sync.Map{}
		fieldIndexCache.Store(typ, typCache)
	}

	iindexes, existCache := typCache.(*sync.Map).Load(name)
	if existCache && iindexes != nil {
		finfo := iindexes.(*fieldInfo)
		var err error
		if len(finfo.indexes) == 0 {
			err = perrors.Errorf("failed to find field %s", name)
		}
		return finfo.indexes, finfo.field, err
	}

	indexes, field, err := findField(name, typ)
	typCache.(*sync.Map).Store(name, &fieldInfo{indexes: indexes, field: field})
	return indexes, field, err
}

// findField find structField in rType
//
// return
//
//	indexes []int
//	field reflect.StructField
//	err error
func findField(name string, typ reflect.Type) ([]int, *reflect.StructField, error) {
	for i := 0; i < typ.NumField(); i++ {
		// matching tag first, then lowerCamelCase, SameCase, lowerCase

		typField := typ.Field(i)

		tagVal, hasTag := typField.Tag.Lookup(tagIdentifier)

		fieldName := typField.Name
		if hasTag && tagVal == name ||
			fieldName == name ||
			lowerCamelCase(fieldName) == name ||
			strings.ToLower(fieldName) == name {

			return []int{i}, &typField, nil
		}

		if typField.Anonymous && typField.Type.Kind() == reflect.Struct {
			next, field, _ := findField(name, typField.Type)
			if len(next) > 0 {
				indexes := []int{i}
				indexes = append(indexes, next...)

				return indexes, field, nil
			}
		}
	}

	return []int{}, nil, perrors.Errorf("failed to find field %s", name)
}

func (d *Decoder) decInstance(typ reflect.Type, cls *ClassInfo) (interface{}, error) {
	if typ.Kind() != reflect.Struct {
		return nil, perrors.Errorf("wrong type expect Struct but get:%s", typ.String())
	}

	vRef := reflect.New(typ)
	// add pointer ref so that ref the same object
	d.appendRefs(vRef.Interface())

	vv := vRef.Elem()
	for i := 0; i < len(cls.fieldNameList); i++ {
		fieldName := cls.fieldNameList[i]

		index, fieldStruct, err := findFieldWithCache(fieldName, typ)
		if err != nil {
			d.DecodeValue()
			continue
		}

		// skip unexported anonymous field
		if fieldStruct.PkgPath != "" {
			continue
		}

		field := vv.FieldByIndex(index)
		if !field.CanSet() {
			return nil, perrors.Errorf("decInstance CanSet false for field %s", fieldName)
		}

		// get field type from type object, not do that from value
		fldTyp := UnpackPtrType(field.Type())

		// unpack pointer to enable value setting
		fldRawValue := UnpackPtrValue(field)
		kind := fldTyp.Kind()

		switch kind {
		case reflect.String:
			str, err := d.decString(TAG_READ)
			if err != nil {
				return nil, perrors.Wrapf(err, "decInstance->ReadString: %s", fieldName)
			}
			fldRawValue.SetString(str)

		case reflect.Int32, reflect.Int16, reflect.Int8:
			num, err := d.decInt32(TAG_READ)
			if err != nil {
				// java enum
				if fldRawValue.Type().Implements(javaEnumType) {
					_ = d.unreadByte() // Enum parsing, decInt64 above has read a byte, so you need to return a byte here
					enumVal, decErr := d.DecodeValue()
					if decErr != nil {
						return nil, perrors.Wrapf(decErr, "decInstance->decObject field name:%s", fieldName)
					}

					SetValue(fldRawValue, reflect.ValueOf(enumVal))

					continue
				}

				return nil, perrors.Wrapf(err, "decInstance->decInt32, field name:%s", fieldName)
			}

			fldRawValue.SetInt(int64(num))
		case reflect.Uint16, reflect.Uint8:
			num, err := d.decInt32(TAG_READ)
			if err != nil {
				return nil, perrors.Wrapf(err, "decInstance->decInt32, field name:%s", fieldName)
			}
			fldRawValue.SetUint(uint64(num))
		case reflect.Uint, reflect.Int, reflect.Int64:
			num, err := d.decInt64(TAG_READ)
			if err != nil {
				if fldTyp.Implements(javaEnumType) {
					d.unreadByte() // Enum parsing, decInt64 above has read a byte, so you need to return a byte here
					s, decErr := d.Decode()
					if decErr != nil {
						return nil, perrors.Wrapf(decErr, "decInstance->decObject field name:%s", fieldName)
					}
					enumValue, _ := s.(JavaEnum)
					num = int64(enumValue)
				} else {
					return nil, perrors.Wrapf(err, "decInstance->decInt64 field name:%s", fieldName)
				}
			}

			fldRawValue.SetInt(num)
		case reflect.Uint32, reflect.Uint64:
			num, err := d.decInt64(TAG_READ)
			if err != nil {
				return nil, perrors.Wrapf(err, "decInstance->decInt64, field name:%s", fieldName)
			}
			fldRawValue.SetUint(uint64(num))
		case reflect.Bool:
			b, err := d.Decode()
			if err != nil {
				return nil, perrors.Wrapf(err, "decInstance->Decode field name:%s", fieldName)
			}
			v, ok := b.(bool)
			if !ok {
				return nil, perrors.Errorf("value convert to bool failed, field name:%s", fieldName)
			}

			if fldRawValue.Kind() == reflect.Ptr && fldRawValue.CanSet() {
				if b != nil {
					field.Set(reflect.ValueOf(&v))
				}
			} else if fldRawValue.Kind() != reflect.Ptr {
				fldRawValue.SetBool(v)
			}

		case reflect.Float32, reflect.Float64:
			num, err := d.decDouble(TAG_READ)
			if err != nil {
				return nil, perrors.Wrapf(err, "decInstance->decDouble field name:%s", fieldName)
			}
			fldRawValue.SetFloat(num.(float64))

		case reflect.Map:
			// decode map should use the original field value for correct value setting
			err := d.decMapByValue(field)
			if err != nil {
				return nil, perrors.Wrapf(err, "decInstance->decMapByValue field name: %s", fieldName)
			}

		case reflect.Slice, reflect.Array:
			m, err := d.decList(TAG_READ)
			if err != nil {
				if perrors.Is(err, io.EOF) {
					break
				}
				return nil, perrors.WithStack(err)
			}

			// set slice separately
			err = SetSlice(fldRawValue, m)
			if err != nil {
				return nil, err
			}
		case reflect.Struct:
			var (
				err error
				s   interface{}
			)
			fldType := UnpackPtrType(fldRawValue.Type())
			if fldType.String() == "time.Time" {
				s, err = d.decDate(TAG_READ)
				if err != nil {
					return nil, perrors.WithStack(err)
				}
				SetValue(fldRawValue, EnsurePackValue(s))
			} else {
				s, err = d.decObject(TAG_READ)
				if err != nil {
					return nil, perrors.WithStack(err)
				}
				if s != nil {
					// set value which accepting pointers
					SetValue(fldRawValue, EnsurePackValue(s))
				}
			}
		case reflect.Interface:
			s, err := d.DecodeValue()
			if err != nil {
				return nil, perrors.WithStack(err)
			}
			if s != nil {
				if ref, ok := s.(*_refHolder); ok {
					_ = unpackRefHolder(fldRawValue, fldTyp, ref)
				} else {
					// set value which accepting pointers
					SetValue(fldRawValue, EnsurePackValue(s))
				}
			}
		default:
			return nil, perrors.Errorf("unknown struct member type: %v %v", kind, typ.Name()+"."+fieldStruct.Name)
		}
	} // end for

	return vRef.Interface(), nil
}

func (d *Decoder) appendClsDef(cd *ClassInfo) {
	d.classInfoList = append(d.classInfoList, cd)
}

func (d *Decoder) getStructDefByIndex(idx int) (reflect.Type, *ClassInfo, error) {
	var (
		ok  bool
		cls *ClassInfo
		s   *structInfo
		err error
	)

	if len(d.classInfoList) <= idx || idx < 0 {
		return nil, cls, perrors.Errorf("illegal class index @idx %d", idx)
	}
	cls = d.classInfoList[idx]
	s, ok = getStructInfo(cls.javaName)
	if !ok {
		// exception
		if s, ok = checkAndGetException(cls); ok {
			return s.typ, cls, nil
		}
		if !d.isSkip && d.Strict {
			err = perrors.Errorf("can not find go type name %s in registry", cls.javaName)
		}
		return nil, cls, err
	}

	return s.typ, cls, nil
}

func (d *Decoder) decEnum(javaName string, flag int32) (interface{}, error) {
	var (
		err       error
		enumName  string
		ok        bool
		info      *structInfo
		enumValue JavaEnum
	)
	enumName, err = d.decString(TAG_READ) // java enum class member is "name"
	if err != nil {
		return InvalidJavaEnum, perrors.Wrap(err, "decString for decJavaEnum")
	}
	info, ok = getStructInfo(javaName)
	if !ok {
		return InvalidJavaEnum, perrors.Errorf("getStructInfo(javaName:%s) = false", javaName)
	}

	enumValue = info.inst.(POJOEnum).EnumValue(enumName)
	enumVal := PackPtr(reflect.ValueOf(enumValue).Convert(info.typ)).Interface()
	d.appendRefs(enumVal)
	return enumVal, nil
}

// skip this object
func (d *Decoder) skip(cls *ClassInfo) error {
	fieldLen := len(cls.fieldNameList)
	if fieldLen < 1 {
		return nil
	}

	for i := 0; i < fieldLen; i++ {
		// skip class fields.
		if _, err := d.DecodeValue(); err != nil {
			return err
		}
	}

	return nil
}

func (d *Decoder) decObject(flag int32) (interface{}, error) {
	var (
		tag byte
		idx int32
		err error
		typ reflect.Type
		cls *ClassInfo
	)

	if flag != TAG_READ {
		tag = byte(flag)
	} else {
		tag, _ = d.ReadByte()
	}

	switch {
	case tag == BC_NULL:
		return nil, nil
	case tag == BC_REF:
		return d.decRef(int32(tag))
	case tag == BC_OBJECT_DEF:
		clsDef, decErr := d.decClassDef()
		if decErr != nil {
			return nil, perrors.Wrap(decErr, "decObject->decClassDef byte double")
		}
		cls, _ = clsDef.(*ClassInfo)
		// add to slice
		d.appendClsDef(cls)

		return d.DecodeValue()

	case tag == BC_OBJECT:
		idx, err = d.decInt32(TAG_READ)
		if err != nil {
			return nil, err
		}

		typ, cls, err = d.getStructDefByIndex(int(idx))
		if err != nil {
			return nil, err
		}
		if typ == nil {
			if d.isSkip {
				return nil, d.skip(cls)
			}
			return d.decClassToMap(cls)
		}
		if typ.Implements(javaEnumType) {
			return d.decEnum(cls.javaName, TAG_READ)
		}

		if c, ok := GetSerializer(cls.javaName); ok {
			return c.DecObject(d, typ, cls)
		}

		return d.decInstance(typ, cls)

	case BC_OBJECT_DIRECT <= tag && tag <= (BC_OBJECT_DIRECT+OBJECT_DIRECT_MAX):
		typ, cls, err = d.getStructDefByIndex(int(tag - BC_OBJECT_DIRECT))
		if err != nil {
			return nil, err
		}
		if typ == nil {
			if d.isSkip {
				return nil, d.skip(cls)
			}
			return d.decClassToMap(cls)
		}
		if typ.Implements(javaEnumType) {
			return d.decEnum(cls.javaName, TAG_READ)
		}

		if c, ok := GetSerializer(cls.javaName); ok {
			return c.DecObject(d, typ, cls)
		}

		return d.decInstance(typ, cls)

	default:
		return nil, perrors.Errorf("decObject illegal object type tag:%+v", tag)
	}
}

func (d *Decoder) decClassToMap(cls *ClassInfo) (interface{}, error) {
	vMap := make(map[string]interface{}, len(cls.fieldNameList))
	vMap[ClassKey] = cls.javaName

	d.appendRefs(vMap)

	for i := 0; i < len(cls.fieldNameList); i++ {
		fieldName := cls.fieldNameList[i]

		fieldValue, decErr := d.DecodeValue()
		if decErr != nil {
			return nil, perrors.Wrapf(decErr, "decClassToMap -> decode field name:%s", fieldName)
		}
		vMap[fieldName] = EnsureRawAny(fieldValue)
	}

	return vMap, nil
}