pojo.go - dubbo-go-hessian2 - Git at Google

 /*
  * 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 (
 	"fmt"
 	"reflect"
 	"strings"
 	"sync"
 	"unicode"
 )

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

 // invalid consts
 const (
 	InvalidJavaEnum JavaEnum = -1

 	ClassKey = "_class"
 )

 // struct filed tag of hessian
 var tagIdentifier = "hessian"

 // SetTagIdentifier for customize struct filed tag of hessian, your can use it like:
 //
 //	hessian.SetTagIdentifier("json")
 //	type MyUser struct {
 //		UserFullName      string   `json:"user_full_name"`
 //		FamilyPhoneNumber string   // default convert to => familyPhoneNumber
 //	}
 //	var user MyUser
 //	hessian.NewEncoder().Encode(user)
 func SetTagIdentifier(s string) { tagIdentifier = s }

 // POJO interface
 // !!! Pls attention that Every field name should be upper case.
 // Otherwise the app may panic.
 type POJO interface {
 	JavaClassName() string // got a go struct's Java Class package name which should be a POJO class.
 }

 // POJOEnum enum for POJO
 type POJOEnum interface {
 	POJO
 	String() string
 	EnumValue(string) JavaEnum
 }

 // JavaEnum type
 type JavaEnum int32

 // JavaEnumClass struct
 type JavaEnumClass struct {
 	name string
 }

 type ClassInfo struct {
 	javaName      string
 	fieldNameList []string
 	buffer        []byte // encoded buffer
 }

 type structInfo struct {
 	typ      reflect.Type
 	goName   string
 	javaName string
 	index    int // classInfoList index
 	inst     interface{}
 }

 // POJORegistry pojo registry struct
 type POJORegistry struct {
 	sync.RWMutex
 	classInfoList []*ClassInfo           // {class name, field name list...} list
 	j2g           map[string]string      // java class name --> go struct name
 	registry      map[string]*structInfo // go class name --> go struct info
 }

 var (
 	pojoRegistry = &POJORegistry{
 		j2g:      make(map[string]string),
 		registry: make(map[string]*structInfo),
 	}
 	pojoType     = reflect.TypeOf((*POJO)(nil)).Elem()
 	javaEnumType = reflect.TypeOf((*POJOEnum)(nil)).Elem()
 )

 // initDefBuffer initial the class definition buffer, which can be used repeatedly.
 func (c *ClassInfo) initDefBuffer() {
 	if len(c.buffer) == 0 {
 		c.buffer = encByte(c.buffer, BC_OBJECT_DEF)
 		c.buffer = encString(c.buffer, c.javaName)
 		c.buffer = encInt32(c.buffer, int32(len(c.fieldNameList)))

 		for _, fieldName := range c.fieldNameList {
 			c.buffer = encString(c.buffer, fieldName)
 		}
 	}
 }

 // struct parsing
 func showPOJORegistry() {
 	pojoRegistry.Lock()
 	for k, v := range pojoRegistry.registry {
 		fmt.Println("-->> show Registered types <<----")
 		fmt.Println(k, v)
 	}
 	pojoRegistry.Unlock()
 }

 // RegisterPOJO Register a POJO instance. The return value is -1 if @o has been registered.
 func RegisterPOJO(o POJO) int {
 	return RegisterPOJOMapping(o.JavaClassName(), o)
 }

 // RegisterPOJOMapping Register a POJO instance. The return value is -1 if @o has been registered.
 func RegisterPOJOMapping(javaClassName string, o interface{}) int {
 	// # definition for an object (compact map)
 	// class-def  ::= 'C' string int string*
 	pojoRegistry.Lock()
 	defer pojoRegistry.Unlock()

 	if goName, ok := pojoRegistry.j2g[javaClassName]; ok {
 		// TODO print warning message about duplicate registration JavaClass
 		return pojoRegistry.registry[goName].index
 	}

 	// JavaClassName shouldn't equal to goName
 	if _, ok := pojoRegistry.registry[javaClassName]; ok {
 		return -1
 	}

 	return registerPOJOTypeMapping(javaClassName, GetGoType(o), obtainValueType(o), o)
 }

 // registerPOJOTypeMapping Register a POJO instance for given type.
 // It's used internally to register special types directly.
 func registerPOJOTypeMapping(javaClassName string, goName string, typ reflect.Type, o interface{}) int {
 	var (
 		bHeader   []byte
 		bBody     []byte
 		fieldList []string
 		sttInfo   structInfo
 		clsDef    ClassInfo
 	)

 	sttInfo.typ = typ
 	sttInfo.goName = goName
 	sttInfo.javaName = javaClassName
 	sttInfo.inst = o
 	pojoRegistry.j2g[sttInfo.javaName] = sttInfo.goName
 	registerListNameMapping(sttInfo.goName, sttInfo.javaName)

 	// prepare fields info of objectDef
 	nextStruct := []reflect.Type{sttInfo.typ}
 	for len(nextStruct) > 0 {
 		current := nextStruct[0]
 		if current.Kind() == reflect.Struct {
 			for i := 0; i < current.NumField(); i++ {
 				// skip unexported anonymous filed
 				if current.Field(i).PkgPath != "" {
 					continue
 				}

 				structField := current.Field(i)

 				// skip ignored field
 				tagVal, hasTag := structField.Tag.Lookup(tagIdentifier)
 				if tagVal == `-` {
 					continue
 				}

 				// flat anonymous field
 				if structField.Anonymous && structField.Type.Kind() == reflect.Struct {
 					nextStruct = append(nextStruct, structField.Type)
 					continue
 				}

 				var fieldName string
 				if hasTag {
 					fieldName = tagVal
 				} else {
 					fieldName = lowerCamelCase(structField.Name)
 				}

 				fieldList = append(fieldList, fieldName)
 				bBody = encString(bBody, fieldName)
 			}
 		}

 		nextStruct = nextStruct[1:]
 	}

 	// prepare header of objectDef
 	bHeader = encByte(bHeader, BC_OBJECT_DEF)
 	bHeader = encString(bHeader, sttInfo.javaName)

 	// write fields length into header of objectDef
 	// note: cause fieldList is a dynamic slice, so one must calculate length only after it being prepared already.
 	bHeader = encInt32(bHeader, int32(len(fieldList)))

 	// prepare classDef
 	clsDef = ClassInfo{javaName: sttInfo.javaName, fieldNameList: fieldList}

 	// merge header and body of objectDef into buffer of ClassInfo
 	clsDef.buffer = append(bHeader, bBody...)

 	sttInfo.index = len(pojoRegistry.classInfoList)
 	pojoRegistry.classInfoList = append(pojoRegistry.classInfoList, &clsDef)
 	pojoRegistry.registry[sttInfo.goName] = &sttInfo

 	return sttInfo.index
 }

 // UnRegisterPOJOs unregister POJO instances. It is easy for test.
 func UnRegisterPOJOs(os ...POJO) []int {
 	arr := make([]int, len(os))
 	for i := range os {
 		arr[i] = unRegisterPOJO(os[i])
 	}

 	return arr
 }

 func unRegisterPOJO(o POJO) int {
 	pojoRegistry.Lock()
 	defer pojoRegistry.Unlock()

 	goName := GetGoType(o)

 	if pojoStructInfo, ok := pojoRegistry.registry[goName]; ok {
 		delete(pojoRegistry.j2g, pojoStructInfo.javaName)
 		listTypeNameMapper.Delete(pojoStructInfo.goName)
 		// remove registry cache.
 		delete(pojoRegistry.registry, pojoStructInfo.goName)
 		// don't remove registry classInfoList,
 		// indexes of registered pojo may be affected.
 		return pojoStructInfo.index
 	}

 	return -1
 }

 // GetGoType get the raw go type name with package.
 func GetGoType(o interface{}) string {
 	return combineGoTypeName(reflect.TypeOf(o))
 }

 func combineGoTypeName(t reflect.Type) string {
 	for reflect.Ptr == t.Kind() {
 		t = t.Elem()
 	}

 	if reflect.Slice == t.Kind() {
 		goName := t.String()
 		sliceArrayPrefixIndex := strings.LastIndex(goName, "]")
 		for reflect.Slice == t.Kind() {
 			t = t.Elem()
 		}
 		return goName[:sliceArrayPrefixIndex+1] + combineGoTypeName(t)
 	}

 	pkgPath := t.PkgPath()
 	goName := t.String()
 	if pkgPath == "" || strings.HasPrefix(goName, pkgPath) {
 		return goName
 	}
 	return pkgPath + "/" + goName
 }

 func obtainValueType(o interface{}) reflect.Type {
 	v := reflect.ValueOf(o)
 	switch v.Kind() {
 	case reflect.Struct:
 		return v.Type()
 	case reflect.Ptr:
 		return v.Elem().Type()
 	}

 	return reflect.TypeOf(o)
 }

 // RegisterPOJOs register a POJO instance arr @os. The return value is @os's
 // mathching index array, in which "-1" means its matching POJO has been registered.
 func RegisterPOJOs(os ...POJO) []int {
 	arr := make([]int, len(os))
 	for i := range os {
 		arr[i] = RegisterPOJO(os[i])
 	}

 	return arr
 }

 // RegisterJavaEnum Register a value type JavaEnum variable.
 func RegisterJavaEnum(o POJOEnum) int {
 	var (
 		ok bool
 		b  []byte
 		i  int
 		n  int
 		f  string
 		l  []string
 		t  structInfo
 		c  ClassInfo
 		v  reflect.Value
 	)

 	pojoRegistry.Lock()
 	defer pojoRegistry.Unlock()
 	if _, ok = pojoRegistry.registry[o.JavaClassName()]; !ok {
 		v = reflect.ValueOf(o)
 		switch v.Kind() {
 		case reflect.Struct:
 			t.typ = v.Type()
 		case reflect.Ptr:
 			t.typ = v.Elem().Type()
 		default:
 			t.typ = reflect.TypeOf(o)
 		}
 		t.goName = GetGoType(o)
 		t.javaName = o.JavaClassName()
 		t.inst = o
 		pojoRegistry.j2g[t.javaName] = t.goName

 		b = b[:0]
 		b = encByte(b, BC_OBJECT_DEF)
 		b = encString(b, t.javaName)
 		l = l[:0]
 		n = 1
 		b = encInt32(b, int32(n))
 		f = strings.ToLower("name")
 		l = append(l, f)
 		b = encString(b, f)

 		c = ClassInfo{javaName: t.javaName, fieldNameList: l}
 		c.buffer = append(c.buffer, b[:]...)
 		t.index = len(pojoRegistry.classInfoList)
 		pojoRegistry.classInfoList = append(pojoRegistry.classInfoList, &c)
 		pojoRegistry.registry[t.goName] = &t
 		i = t.index
 	} else {
 		i = -1
 	}

 	return i
 }

 // check if go struct name @goName has been registered or not.
 func checkPOJORegistry(v interface{}) (int, bool) {
 	s, ok := loadPOJORegistry(v)
 	if !ok {
 		return -1, false
 	}
 	return s.index, true
 }

 // load struct info if go struct name @goName has been registered or not.
 func loadPOJORegistry(v interface{}) (*structInfo, bool) {
 	var (
 		ok bool
 		s  *structInfo
 	)
 	goName := GetGoType(v)
 	pojoRegistry.RLock()
 	s, ok = pojoRegistry.registry[goName]
 	pojoRegistry.RUnlock()

 	return s, ok
 }

 // @typeName is class's java name
 func getStructInfo(javaName string) (*structInfo, bool) {
 	pojoRegistry.RLock()
 	defer pojoRegistry.RUnlock()

 	if g, ok := pojoRegistry.j2g[javaName]; ok {
 		s, b := pojoRegistry.registry[g]
 		return s, b
 	}

 	return nil, false
 }

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

 	pojoRegistry.RLock()
 	defer pojoRegistry.RUnlock()

 	if len(pojoRegistry.classInfoList) <= idx || idx < 0 {
 		return nil, cls, perrors.Errorf("illegal class index @idx %d", idx)
 	}
 	cls = pojoRegistry.classInfoList[idx]
 	clsName, ok = pojoRegistry.j2g[cls.javaName]
 	if !ok {
 		return nil, cls, perrors.Errorf("can not find java type name %s in registry", cls.javaName)
 	}
 	s, ok = pojoRegistry.registry[clsName]
 	if !ok {
 		return nil, cls, perrors.Errorf("can not find go type name %s in registry", clsName)
 	}

 	return s.typ, cls, nil
 }

 // Create a new instance by its struct name is @goName.
 // the return value is nil if @o has been registered.
 func createInstance(goName string) interface{} {
 	var (
 		ok bool
 		s  *structInfo
 	)

 	pojoRegistry.RLock()
 	s, ok = pojoRegistry.registry[goName]
 	pojoRegistry.RUnlock()
 	if !ok {
 		return nil
 	}

 	if s.typ.Kind() == reflect.Map {
 		return reflect.MakeMap(s.typ).Interface()
 	}

 	return reflect.New(s.typ).Interface()
 }

 func lowerCamelCase(s string) string {
 	runes := []rune(s)
 	runes[0] = unicode.ToLower(runes[0])
 	return string(runes)
 }

 // buildMapClassDef build ClassInfo from map keys.
 func buildMapClassDef(javaName string, m map[string]interface{}) (*ClassInfo, error) {
 	if javaName == "" {
 		var ok bool
 		javaName, ok = m[ClassKey].(string)
 		if !ok {
 			return nil, perrors.Errorf("no java name to build class info from map: %v", m)
 		}
 	}

 	info := &ClassInfo{javaName: javaName}

 	_, existClassKey := m[ClassKey]

 	for fieldName := range m {
 		if existClassKey && fieldName == ClassKey {
 			continue
 		}

 		info.fieldNameList = append(info.fieldNameList, fieldName)
 	}

 	info.initDefBuffer()

 	return info, nil
 }
	/*
	* 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 (
	"fmt"
	"reflect"
	"strings"
	"sync"
	"unicode"
	)

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

	// invalid consts
	const (
	InvalidJavaEnum JavaEnum = -1

	ClassKey = "_class"
	)

	// struct filed tag of hessian
	var tagIdentifier = "hessian"

	// SetTagIdentifier for customize struct filed tag of hessian, your can use it like:
	//
	// hessian.SetTagIdentifier("json")
	// type MyUser struct {
	// UserFullName string `json:"user_full_name"`
	// FamilyPhoneNumber string // default convert to => familyPhoneNumber
	// }
	// var user MyUser
	// hessian.NewEncoder().Encode(user)
	func SetTagIdentifier(s string) { tagIdentifier = s }

	// POJO interface
	// !!! Pls attention that Every field name should be upper case.
	// Otherwise the app may panic.
	type POJO interface {
	JavaClassName() string // got a go struct's Java Class package name which should be a POJO class.
	}

	// POJOEnum enum for POJO
	type POJOEnum interface {
	POJO
	String() string
	EnumValue(string) JavaEnum
	}

	// JavaEnum type
	type JavaEnum int32

	// JavaEnumClass struct
	type JavaEnumClass struct {
	name string
	}

	type ClassInfo struct {
	javaName string
	fieldNameList []string
	buffer []byte // encoded buffer
	}

	type structInfo struct {
	typ reflect.Type
	goName string
	javaName string
	index int // classInfoList index
	inst interface{}
	}

	// POJORegistry pojo registry struct
	type POJORegistry struct {
	sync.RWMutex
	classInfoList []*ClassInfo // {class name, field name list...} list
	j2g map[string]string // java class name --> go struct name
	registry map[string]*structInfo // go class name --> go struct info
	}

	var (
	pojoRegistry = &POJORegistry{
	j2g: make(map[string]string),
	registry: make(map[string]*structInfo),
	}
	pojoType = reflect.TypeOf((*POJO)(nil)).Elem()
	javaEnumType = reflect.TypeOf((*POJOEnum)(nil)).Elem()
	)

	// initDefBuffer initial the class definition buffer, which can be used repeatedly.
	func (c *ClassInfo) initDefBuffer() {
	if len(c.buffer) == 0 {
	c.buffer = encByte(c.buffer, BC_OBJECT_DEF)
	c.buffer = encString(c.buffer, c.javaName)
	c.buffer = encInt32(c.buffer, int32(len(c.fieldNameList)))

	for _, fieldName := range c.fieldNameList {
	c.buffer = encString(c.buffer, fieldName)
	}
	}
	}

	// struct parsing
	func showPOJORegistry() {
	pojoRegistry.Lock()
	for k, v := range pojoRegistry.registry {
	fmt.Println("-->> show Registered types <<----")
	fmt.Println(k, v)
	}
	pojoRegistry.Unlock()
	}

	// RegisterPOJO Register a POJO instance. The return value is -1 if @o has been registered.
	func RegisterPOJO(o POJO) int {
	return RegisterPOJOMapping(o.JavaClassName(), o)
	}

	// RegisterPOJOMapping Register a POJO instance. The return value is -1 if @o has been registered.
	func RegisterPOJOMapping(javaClassName string, o interface{}) int {
	// # definition for an object (compact map)
	// class-def ::= 'C' string int string*
	pojoRegistry.Lock()
	defer pojoRegistry.Unlock()

	if goName, ok := pojoRegistry.j2g[javaClassName]; ok {
	// TODO print warning message about duplicate registration JavaClass
	return pojoRegistry.registry[goName].index
	}

	// JavaClassName shouldn't equal to goName
	if _, ok := pojoRegistry.registry[javaClassName]; ok {
	return -1
	}

	return registerPOJOTypeMapping(javaClassName, GetGoType(o), obtainValueType(o), o)
	}

	// registerPOJOTypeMapping Register a POJO instance for given type.
	// It's used internally to register special types directly.
	func registerPOJOTypeMapping(javaClassName string, goName string, typ reflect.Type, o interface{}) int {
	var (
	bHeader []byte
	bBody []byte
	fieldList []string
	sttInfo structInfo
	clsDef ClassInfo
	)

	sttInfo.typ = typ
	sttInfo.goName = goName
	sttInfo.javaName = javaClassName
	sttInfo.inst = o
	pojoRegistry.j2g[sttInfo.javaName] = sttInfo.goName
	registerListNameMapping(sttInfo.goName, sttInfo.javaName)

	// prepare fields info of objectDef
	nextStruct := []reflect.Type{sttInfo.typ}
	for len(nextStruct) > 0 {
	current := nextStruct[0]
	if current.Kind() == reflect.Struct {
	for i := 0; i < current.NumField(); i++ {
	// skip unexported anonymous filed
	if current.Field(i).PkgPath != "" {
	continue
	}

	structField := current.Field(i)

	// skip ignored field
	tagVal, hasTag := structField.Tag.Lookup(tagIdentifier)
	if tagVal == `-` {
	continue
	}

	// flat anonymous field
	if structField.Anonymous && structField.Type.Kind() == reflect.Struct {
	nextStruct = append(nextStruct, structField.Type)
	continue
	}

	var fieldName string
	if hasTag {
	fieldName = tagVal
	} else {
	fieldName = lowerCamelCase(structField.Name)
	}

	fieldList = append(fieldList, fieldName)
	bBody = encString(bBody, fieldName)
	}
	}

	nextStruct = nextStruct[1:]
	}

	// prepare header of objectDef
	bHeader = encByte(bHeader, BC_OBJECT_DEF)
	bHeader = encString(bHeader, sttInfo.javaName)

	// write fields length into header of objectDef
	// note: cause fieldList is a dynamic slice, so one must calculate length only after it being prepared already.
	bHeader = encInt32(bHeader, int32(len(fieldList)))

	// prepare classDef
	clsDef = ClassInfo{javaName: sttInfo.javaName, fieldNameList: fieldList}

	// merge header and body of objectDef into buffer of ClassInfo
	clsDef.buffer = append(bHeader, bBody...)

	sttInfo.index = len(pojoRegistry.classInfoList)
	pojoRegistry.classInfoList = append(pojoRegistry.classInfoList, &clsDef)
	pojoRegistry.registry[sttInfo.goName] = &sttInfo

	return sttInfo.index
	}

	// UnRegisterPOJOs unregister POJO instances. It is easy for test.
	func UnRegisterPOJOs(os ...POJO) []int {
	arr := make([]int, len(os))
	for i := range os {
	arr[i] = unRegisterPOJO(os[i])
	}

	return arr
	}

	func unRegisterPOJO(o POJO) int {
	pojoRegistry.Lock()
	defer pojoRegistry.Unlock()

	goName := GetGoType(o)

	if pojoStructInfo, ok := pojoRegistry.registry[goName]; ok {
	delete(pojoRegistry.j2g, pojoStructInfo.javaName)
	listTypeNameMapper.Delete(pojoStructInfo.goName)
	// remove registry cache.
	delete(pojoRegistry.registry, pojoStructInfo.goName)
	// don't remove registry classInfoList,
	// indexes of registered pojo may be affected.
	return pojoStructInfo.index
	}

	return -1
	}

	// GetGoType get the raw go type name with package.
	func GetGoType(o interface{}) string {
	return combineGoTypeName(reflect.TypeOf(o))
	}

	func combineGoTypeName(t reflect.Type) string {
	for reflect.Ptr == t.Kind() {
	t = t.Elem()
	}

	if reflect.Slice == t.Kind() {
	goName := t.String()
	sliceArrayPrefixIndex := strings.LastIndex(goName, "]")
	for reflect.Slice == t.Kind() {
	t = t.Elem()
	}
	return goName[:sliceArrayPrefixIndex+1] + combineGoTypeName(t)
	}

	pkgPath := t.PkgPath()
	goName := t.String()
	if pkgPath == "" \|\| strings.HasPrefix(goName, pkgPath) {
	return goName
	}
	return pkgPath + "/" + goName
	}

	func obtainValueType(o interface{}) reflect.Type {
	v := reflect.ValueOf(o)
	switch v.Kind() {
	case reflect.Struct:
	return v.Type()
	case reflect.Ptr:
	return v.Elem().Type()
	}

	return reflect.TypeOf(o)
	}

	// RegisterPOJOs register a POJO instance arr @os. The return value is @os's
	// mathching index array, in which "-1" means its matching POJO has been registered.
	func RegisterPOJOs(os ...POJO) []int {
	arr := make([]int, len(os))
	for i := range os {
	arr[i] = RegisterPOJO(os[i])
	}

	return arr
	}

	// RegisterJavaEnum Register a value type JavaEnum variable.
	func RegisterJavaEnum(o POJOEnum) int {
	var (
	ok bool
	b []byte
	i int
	n int
	f string
	l []string
	t structInfo
	c ClassInfo
	v reflect.Value
	)

	pojoRegistry.Lock()
	defer pojoRegistry.Unlock()
	if _, ok = pojoRegistry.registry[o.JavaClassName()]; !ok {
	v = reflect.ValueOf(o)
	switch v.Kind() {
	case reflect.Struct:
	t.typ = v.Type()
	case reflect.Ptr:
	t.typ = v.Elem().Type()
	default:
	t.typ = reflect.TypeOf(o)
	}
	t.goName = GetGoType(o)
	t.javaName = o.JavaClassName()
	t.inst = o
	pojoRegistry.j2g[t.javaName] = t.goName

	b = b[:0]
	b = encByte(b, BC_OBJECT_DEF)
	b = encString(b, t.javaName)
	l = l[:0]
	n = 1
	b = encInt32(b, int32(n))
	f = strings.ToLower("name")
	l = append(l, f)
	b = encString(b, f)

	c = ClassInfo{javaName: t.javaName, fieldNameList: l}
	c.buffer = append(c.buffer, b[:]...)
	t.index = len(pojoRegistry.classInfoList)
	pojoRegistry.classInfoList = append(pojoRegistry.classInfoList, &c)
	pojoRegistry.registry[t.goName] = &t
	i = t.index
	} else {
	i = -1
	}

	return i
	}

	// check if go struct name @goName has been registered or not.
	func checkPOJORegistry(v interface{}) (int, bool) {
	s, ok := loadPOJORegistry(v)
	if !ok {
	return -1, false
	}
	return s.index, true
	}

	// load struct info if go struct name @goName has been registered or not.
	func loadPOJORegistry(v interface{}) (*structInfo, bool) {
	var (
	ok bool
	s *structInfo
	)
	goName := GetGoType(v)
	pojoRegistry.RLock()
	s, ok = pojoRegistry.registry[goName]
	pojoRegistry.RUnlock()

	return s, ok
	}

	// @typeName is class's java name
	func getStructInfo(javaName string) (*structInfo, bool) {
	pojoRegistry.RLock()
	defer pojoRegistry.RUnlock()

	if g, ok := pojoRegistry.j2g[javaName]; ok {
	s, b := pojoRegistry.registry[g]
	return s, b
	}

	return nil, false
	}

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

	pojoRegistry.RLock()
	defer pojoRegistry.RUnlock()

	if len(pojoRegistry.classInfoList) <= idx \|\| idx < 0 {
	return nil, cls, perrors.Errorf("illegal class index @idx %d", idx)
	}
	cls = pojoRegistry.classInfoList[idx]
	clsName, ok = pojoRegistry.j2g[cls.javaName]
	if !ok {
	return nil, cls, perrors.Errorf("can not find java type name %s in registry", cls.javaName)
	}
	s, ok = pojoRegistry.registry[clsName]
	if !ok {
	return nil, cls, perrors.Errorf("can not find go type name %s in registry", clsName)
	}

	return s.typ, cls, nil
	}

	// Create a new instance by its struct name is @goName.
	// the return value is nil if @o has been registered.
	func createInstance(goName string) interface{} {
	var (
	ok bool
	s *structInfo
	)

	pojoRegistry.RLock()
	s, ok = pojoRegistry.registry[goName]
	pojoRegistry.RUnlock()
	if !ok {
	return nil
	}

	if s.typ.Kind() == reflect.Map {
	return reflect.MakeMap(s.typ).Interface()
	}

	return reflect.New(s.typ).Interface()
	}

	func lowerCamelCase(s string) string {
	runes := []rune(s)
	runes[0] = unicode.ToLower(runes[0])
	return string(runes)
	}

	// buildMapClassDef build ClassInfo from map keys.
	func buildMapClassDef(javaName string, m map[string]interface{}) (*ClassInfo, error) {
	if javaName == "" {
	var ok bool
	javaName, ok = m[ClassKey].(string)
	if !ok {
	return nil, perrors.Errorf("no java name to build class info from map: %v", m)
	}
	}

	info := &ClassInfo{javaName: javaName}

	_, existClassKey := m[ClassKey]

	for fieldName := range m {
	if existClassKey && fieldName == ClassKey {
	continue
	}

	info.fieldNameList = append(info.fieldNameList, fieldName)
	}

	info.initDefBuffer()

	return info, nil
	}