func (orig *PeopleJSON) Convert() (*People, error) {
	ret := &People{}
	b := NewPeopleJSONBuilder().AddAll()
	for _, info := range b._properties {
		if err := info.Decoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
Convert specified JSON object to non-JSON object.
package i
import (
	"encoding/json"
)
type PersonJSON struct {
	Name     string `json:"name,omitempty"`
	Age      int    `json:"age,omitempty"`
	Password string `json:"password,omitempty"`
}
type PersonJSONList []*PersonJSON
type PersonPropertyEncoder func(src *Person, dest *PersonJSON) error
type PersonPropertyDecoder func(src *PersonJSON, dest *Person) error
type PersonPropertyInfo struct {
	fieldName string
	jsonName  string
	Encoder   PersonPropertyEncoder
	Decoder   PersonPropertyDecoder
}
func (info *PersonPropertyInfo) FieldName() string {
	return info.fieldName
}
func (info *PersonPropertyInfo) JSONName() string {
	return info.jsonName
}
type PersonJSONBuilder struct {
	_properties        map[string]*PersonPropertyInfo
	_jsonPropertyMap   map[string]*PersonPropertyInfo
	_structPropertyMap map[string]*PersonPropertyInfo
	Name               *PersonPropertyInfo
	Age                *PersonPropertyInfo
	Password           *PersonPropertyInfo
}
func NewPersonJSONBuilder() *PersonJSONBuilder {
	jb := &PersonJSONBuilder{
		_properties:        map[string]*PersonPropertyInfo{},
		_jsonPropertyMap:   map[string]*PersonPropertyInfo{},
		_structPropertyMap: map[string]*PersonPropertyInfo{},
		Name: &PersonPropertyInfo{
			fieldName: "Name",
			jsonName:  "name",
			Encoder: func(src *Person, dest *PersonJSON) error {
				if src == nil {
					return nil
				}
				dest.Name = src.Name
				return nil
			},
			Decoder: func(src *PersonJSON, dest *Person) error {
				if src == nil {
					return nil
				}
				dest.Name = src.Name
				return nil
			},
		},
		Age: &PersonPropertyInfo{
			fieldName: "Age",
			jsonName:  "age",
			Encoder: func(src *Person, dest *PersonJSON) error {
				if src == nil {
					return nil
				}
				dest.Age = src.Age
				return nil
			},
			Decoder: func(src *PersonJSON, dest *Person) error {
				if src == nil {
					return nil
				}
				dest.Age = src.Age
				return nil
			},
		},
		Password: &PersonPropertyInfo{
			fieldName: "Password",
			jsonName:  "password",
			Encoder: func(src *Person, dest *PersonJSON) error {
				if src == nil {
					return nil
				}
				dest.Password = src.Password
				return nil
			},
			Decoder: func(src *PersonJSON, dest *Person) error {
				if src == nil {
					return nil
				}
				dest.Password = src.Password
				return nil
			},
		},
	}
	jb._structPropertyMap["Name"] = jb.Name
	jb._jsonPropertyMap["name"] = jb.Name
	jb._structPropertyMap["Age"] = jb.Age
	jb._jsonPropertyMap["age"] = jb.Age
	jb._structPropertyMap["Password"] = jb.Password
	jb._jsonPropertyMap["password"] = jb.Password
	return jb
}
func (b *PersonJSONBuilder) Properties() []*PersonPropertyInfo {
	return []*PersonPropertyInfo{
		b.Name,
		b.Age,
		b.Password,
	}
}
func (b *PersonJSONBuilder) AddAll() *PersonJSONBuilder {
	b._properties["Name"] = b.Name
	b._properties["Age"] = b.Age
	b._properties["Password"] = b.Password
	return b
}
func (b *PersonJSONBuilder) Add(info *PersonPropertyInfo) *PersonJSONBuilder {
	b._properties[info.fieldName] = info
	return b
}
func (b *PersonJSONBuilder) AddByJSONNames(names ...string) *PersonJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *PersonJSONBuilder) AddByNames(names ...string) *PersonJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *PersonJSONBuilder) Remove(info *PersonPropertyInfo) *PersonJSONBuilder {
	delete(b._properties, info.fieldName)
	return b
}
func (b *PersonJSONBuilder) RemoveByJSONNames(names ...string) *PersonJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *PersonJSONBuilder) RemoveByNames(names ...string) *PersonJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *PersonJSONBuilder) Convert(orig *Person) (*PersonJSON, error) {
	if orig == nil {
		return nil, nil
	}
	ret := &PersonJSON{}
	for _, info := range b._properties {
		if err := info.Encoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
func (b *PersonJSONBuilder) ConvertList(orig []*Person) (PersonJSONList, error) {
	if orig == nil {
		return nil, nil
	}
	list := make(PersonJSONList, len(orig))
	for idx, or := range orig {
		json, err := b.Convert(or)
		if err != nil {
			return nil, err
		}
		list[idx] = json
	}
	return list, nil
}
func (orig *PersonJSON) Convert() (*Person, error) {
	ret := &Person{}
	b := NewPersonJSONBuilder().AddAll()
	for _, info := range b._properties {
		if err := info.Decoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
func (jsonList PersonJSONList) Convert() ([]*Person, error) {
	orig := ([]*PersonJSON)(jsonList)
	list := make([]*Person, len(orig))
	for idx, or := range orig {
		obj, err := or.Convert()
		if err != nil {
			return nil, err
		}
		list[idx] = obj
	}
	return list, nil
}
func (b *PersonJSONBuilder) Marshal(orig *Person) ([]byte, error) {
	ret, err := b.Convert(orig)
	if err != nil {
		return nil, err
	}
	return json.Marshal(ret)
}
type PeopleJSON struct {
	ShowPrivateInfo bool          `json:"showPrivateInfo,omitempty"`
	List            []*PersonJSON `json:"list,omitempty"`
}
type PeopleJSONList []*PeopleJSON
type PeoplePropertyEncoder func(src *People, dest *PeopleJSON) error
type PeoplePropertyDecoder func(src *PeopleJSON, dest *People) error
type PeoplePropertyInfo struct {
	fieldName string
	jsonName  string
	Encoder   PeoplePropertyEncoder
	Decoder   PeoplePropertyDecoder
}
func (info *PeoplePropertyInfo) FieldName() string {
	return info.fieldName
}
func (info *PeoplePropertyInfo) JSONName() string {
	return info.jsonName
}
type PeopleJSONBuilder struct {
	_properties        map[string]*PeoplePropertyInfo
	_jsonPropertyMap   map[string]*PeoplePropertyInfo
	_structPropertyMap map[string]*PeoplePropertyInfo
	ShowPrivateInfo    *PeoplePropertyInfo
	List               *PeoplePropertyInfo
}
func NewPeopleJSONBuilder() *PeopleJSONBuilder {
	jb := &PeopleJSONBuilder{
		_properties:        map[string]*PeoplePropertyInfo{},
		_jsonPropertyMap:   map[string]*PeoplePropertyInfo{},
		_structPropertyMap: map[string]*PeoplePropertyInfo{},
		ShowPrivateInfo: &PeoplePropertyInfo{
			fieldName: "ShowPrivateInfo",
			jsonName:  "showPrivateInfo",
			Encoder: func(src *People, dest *PeopleJSON) error {
				if src == nil {
					return nil
				}
				dest.ShowPrivateInfo = src.ShowPrivateInfo
				return nil
			},
			Decoder: func(src *PeopleJSON, dest *People) error {
				if src == nil {
					return nil
				}
				dest.ShowPrivateInfo = src.ShowPrivateInfo
				return nil
			},
		},
		List: &PeoplePropertyInfo{
			fieldName: "List",
			jsonName:  "list",
			Encoder: func(src *People, dest *PeopleJSON) error {
				if src == nil {
					return nil
				}
				list, err := NewPersonJSONBuilder().AddAll().ConvertList(src.List)
				if err != nil {
					return err
				}
				dest.List = ([]*PersonJSON)(list)
				return nil
			},
			Decoder: func(src *PeopleJSON, dest *People) error {
				if src == nil {
					return nil
				}
				list := make([]*Person, len(src.List))
				for idx, obj := range src.List {
					if obj == nil {
						continue
					}
					d, err := obj.Convert()
					if err != nil {
						return err
					}
					list[idx] = d
				}
				dest.List = list
				return nil
			},
		},
	}
	jb._structPropertyMap["ShowPrivateInfo"] = jb.ShowPrivateInfo
	jb._jsonPropertyMap["showPrivateInfo"] = jb.ShowPrivateInfo
	jb._structPropertyMap["List"] = jb.List
	jb._jsonPropertyMap["list"] = jb.List
	return jb
}
func (b *PeopleJSONBuilder) Properties() []*PeoplePropertyInfo {
	return []*PeoplePropertyInfo{
		b.ShowPrivateInfo,
		b.List,
	}
}
func (b *PeopleJSONBuilder) AddAll() *PeopleJSONBuilder {
	b._properties["ShowPrivateInfo"] = b.ShowPrivateInfo
	b._properties["List"] = b.List
	return b
}
func (b *PeopleJSONBuilder) Add(info *PeoplePropertyInfo) *PeopleJSONBuilder {
	b._properties[info.fieldName] = info
	return b
}
func (b *PeopleJSONBuilder) AddByJSONNames(names ...string) *PeopleJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *PeopleJSONBuilder) AddByNames(names ...string) *PeopleJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *PeopleJSONBuilder) Remove(info *PeoplePropertyInfo) *PeopleJSONBuilder {
	delete(b._properties, info.fieldName)
	return b
}
func (b *PeopleJSONBuilder) RemoveByJSONNames(names ...string) *PeopleJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *PeopleJSONBuilder) RemoveByNames(names ...string) *PeopleJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *PeopleJSONBuilder) Convert(orig *People) (*PeopleJSON, error) {
	if orig == nil {
		return nil, nil
	}
	ret := &PeopleJSON{}
	for _, info := range b._properties {
		if err := info.Encoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
func (b *PeopleJSONBuilder) ConvertList(orig []*People) (PeopleJSONList, error) {
	if orig == nil {
		return nil, nil
	}
	list := make(PeopleJSONList, len(orig))
	for idx, or := range orig {
		json, err := b.Convert(or)
		if err != nil {
			return nil, err
		}
		list[idx] = json
	}
	return list, nil
}