Documentation ¶
Index ¶
- Variables
- func ConvertPathToString(p Path) string
- func InitCommon()
- func LoadConfig(name string, data []byte, v interface{}) error
- func NewAssemblerError(a *Assembler, err error) error
- func NewLoader(name string, data []byte) func(v interface{}) error
- func RegisterConfigLoader(name string, c *ConfigLoader)
- func SetValue(dst, src reflect.Value) error
- type ArrayStep
- type Assembler
- func (a *Assembler) Assemble(v interface{}) (ok bool, err error)
- func (a *Assembler) CheckType(rv reflect.Value) (tp Type, err error)
- func (a *Assembler) Config() *Config
- func (a *Assembler) Part() Part
- func (a *Assembler) Path() Path
- func (a *Assembler) Step() Step
- func (a *Assembler) WithChild(p Part, step Step) *Assembler
- func (a *Assembler) WithConfig(c *Config) *Assembler
- func (a *Assembler) WithPart(p Part) *Assembler
- type AssemblerError
- type AssemblerLazyLoader
- type Checker
- type Config
- type ConfigLoader
- type FieldStep
- type GroupedUnifiers
- func (u *GroupedUnifiers) Append(tp Type, unifier Unifier) *GroupedUnifiers
- func (u *GroupedUnifiers) AppendWith(unifiers *GroupedUnifiers) *GroupedUnifiers
- func (u *GroupedUnifiers) Insert(tp Type, unifier Unifier) *GroupedUnifiers
- func (u *GroupedUnifiers) InsertWith(unifiers *GroupedUnifiers) *GroupedUnifiers
- func (u *GroupedUnifiers) Unify(a *Assembler, rv reflect.Value) (bool, error)
- type InterfaceStep
- type LazyLoader
- type LazyLoaderFunc
- type MapPart
- type Parser
- type Part
- type PartIter
- type Path
- type Step
- type Steps
- type String
- type StringStep
- type Tag
- type Type
- type TypeChecker
- type TypeCheckers
- func (c *TypeCheckers) Append(checkers ...TypeChecker) *TypeCheckers
- func (c *TypeCheckers) AppendWith(checkers *TypeCheckers) *TypeCheckers
- func (c *TypeCheckers) CheckType(a *Assembler, rv reflect.Value) (Type, error)
- func (c *TypeCheckers) Insert(checkers ...TypeChecker) *TypeCheckers
- func (c *TypeCheckers) InsertWith(checkers *TypeCheckers) *TypeCheckers
- type Unifier
- type UnifierFunc
- type Unifiers
Constants ¶
This section is empty.
Variables ¶
var CommonTypeCheckers = NewTypeCheckers().AppendWith(DefaultCommonTypeCheckers())
CommonTypeCheckers common type checkers used in NewCommonConfig
var CommonUnifiers = NewGroupedUnifiers().AppendWith(DefaultCommonUnifiers())
CommonUnifiers common unifiers user in NewCommonConfig
var EmptyAssembler = &Assembler{ path: NewSteps(), }
EmptyAssembler empty assembler
var ErrConfigLoaderNotRegistered = errors.New("config loader not registered")
ErrConfigLoaderNotRegistered error raised when parser not registered.
var ErrNotAssignable = errors.New("value is not assignable")
ErrNotAssignable err raseid when given value not assignable
var ErrNotPtr = errors.New("value to load is not a pointer")
ErrNotPtr error raised when value to load is not a pointer
var ErrNotSetable = errors.New("value cannot set")
ErrNotSetable err raised when value can not set
var NopLazyLoadFunc = reflect.ValueOf(nopAssemblerLazyLoader.LazyLoadConfig)
NopLazyLoadFunc no op assembler lazy load func
var NopLazyLoader = reflect.ValueOf(nopAssemblerLazyLoader)
NopLazyLoader no op assembler lazy loader
var TypeArray = Type("loader.array")
TypeArray field type array
var TypeBool = Type("loader.bool")
TypeBool field type bool
var TypeCheckerBool = &Checker{ Type: TypeBool, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Bool, nil }, }
TypeCheckerBool type checker for bool.
var TypeCheckerEmptyInterface = &Checker{ Type: TypeEmptyInterface, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Interface && rv.Type().NumMethod() == 0, nil }, }
TypeCheckerEmptyInterface type checker for empty interface.
var TypeCheckerFloat32 = &Checker{ Type: TypeFloat32, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Float32, nil }, }
TypeCheckerFloat32 type checker for float32
var TypeCheckerFloat64 = &Checker{ Type: TypeFloat64, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Float64, nil }, }
TypeCheckerFloat64 type checker for float64
var TypeCheckerInt = &Checker{ Type: TypeInt, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Int, nil }, }
TypeCheckerInt type checker for int.
var TypeCheckerInt64 = &Checker{ Type: TypeInt64, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Int64, nil }, }
TypeCheckerInt64 type checker for int64
var TypeCheckerLazyLoadFunc = &Checker{ Type: TypeLazyLoadFunc, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { lt := a.Config().TagLazyLoad if lt == "" { return false, nil } step := a.Step() if step == nil || step.Type() != TypeStructField { return false, nil } field := step.Interface().(reflect.StructField) tag, err := a.Config().GetTag(rv.Type(), field) if err != nil { return false, err } ok := rv.Type().Kind() == reflect.Func && tag != nil && tag.Flags[lt] != "" if ok && rv.IsNil() { rv.Set(NopLazyLoadFunc) } return ok, nil }, }
TypeCheckerLazyLoadFunc type checker for lazy load func.
var TypeCheckerLazyLoader = &Checker{ Type: TypeLazyLoader, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { lt := a.Config().TagLazyLoad if lt == "" { return false, nil } step := a.Step() if step == nil || step.Type() != TypeStructField { return false, nil } field := step.Interface().(reflect.StructField) tag, err := a.Config().GetTag(rv.Type(), field) if err != nil { return false, err } ok := rv.Type().Kind() == reflect.Interface && tag != nil && tag.Flags[lt] != "" if ok && rv.IsNil() { rv.Set(NopLazyLoader) } return ok, nil }, }
TypeCheckerLazyLoader type checker for lazy loader.
var TypeCheckerPtr = &Checker{ Type: TypePtr, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Ptr, nil }, }
TypeCheckerPtr type checker for pointer
var TypeCheckerSlice = &Checker{ Type: TypeSlice, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Slice, nil }, }
TypeCheckerSlice type checker for slice
var TypeCheckerString = &Checker{ Type: TypeString, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.String, nil }, }
TypeCheckerString type checker for string.
var TypeCheckerStringKeyMap = &Checker{ Type: TypeMap, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Map && rv.Type().Key().Kind() == reflect.String, nil }, }
TypeCheckerStringKeyMap type checker for string key map.
var TypeCheckerStruct = &Checker{ Type: TypeStruct, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Struct, nil }, }
TypeCheckerStruct type checker for struct
var TypeCheckerUint = &Checker{ Type: TypeUint, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Uint, nil }, }
TypeCheckerUint type checker for uint.
var TypeCheckerUint64 = &Checker{ Type: TypeUint64, Checker: func(a *Assembler, rv reflect.Value) (bool, error) { return rv.Type().Kind() == reflect.Uint64, nil }, }
TypeCheckerUint64 type checker for uint64
var TypeEmptyInterface = Type("loader.interface{}")
TypeEmptyInterface field type empty interface
var TypeFloat32 = Type("loader.float32")
TypeFloat32 field type float32
var TypeFloat64 = Type("loader.float64")
TypeFloat64 field type float64
var TypeInt = Type("loader.int")
TypeInt filed type int
var TypeInt16 = Type("loader.int16")
TypeInt16 field type int16
var TypeInt64 = Type("loader.int64")
TypeInt64 field type int64
var TypeInt8 = Type("loader.int8")
TypeInt8 field type int8
var TypeLazyLoadFunc = Type("loader.lazyloadfunc")
TypeLazyLoadFunc field type lazyload func
var TypeLazyLoader = Type("loader.lazyloader")
TypeLazyLoader field type lazyloader
var TypeMap = Type("loader.map")
TypeMap field type map
var TypePtr = Type("loader.*")
TypePtr field type pointer
var TypeSlice = Type("loader.slice")
TypeSlice field type slice
var TypeString = Type("loader.string")
TypeString field type string
var TypeStruct = Type("loader.struct")
TypeStruct field type struct
var TypeStructField = Type("loader.structFild")
TypeStructField field type struct field
var TypeUint = Type("loader.uint")
TypeUint field type uint
var TypeUint16 = Type("loader.uint16")
TypeUint16 field type uint16
var TypeUint64 = Type("loader.uint64")
TypeUint64 field type uint64
var TypeUint8 = Type("loader.uint8")
TypeUint8 field type uint8
var TypeUnkonwn = Type("")
TypeUnkonwn field type unkowwn
var UnifierBool = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { v, err := a.Part().Value() if err != nil { return false, err } s, ok := v.(bool) if ok { err = SetValue(rv, reflect.ValueOf(s)) if err != nil { return false, err } return true, nil } return false, nil })
UnifierBool unifier for bool field
var UnifierEmptyInterface = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { iter, err := a.Part().Iter() if err != nil { return false, err } if iter == nil { v, err := a.Part().Value() if err != nil { return false, err } rt := reflect.TypeOf(v) switch rt.Kind() { case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint8, reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int8, reflect.String, reflect.Bool, reflect.Float32, reflect.Float64, reflect.Map, reflect.Slice: err = SetValue(rv, reflect.ValueOf(v)) if err != nil { return false, err } return true, nil } } else { val, err := convertIter(iter) if err != nil { return false, err } if val == nil { return false, nil } err = SetValue(rv, reflect.ValueOf(val)) if err != nil { return false, err } } return false, nil })
UnifierEmptyInterface unifier for empty interface field
var UnifierLazyLoadFunc = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { l := NewLazyLoader() l.Assembler = a err := SetValue(rv, reflect.ValueOf(l.LazyLoadConfig)) if err != nil { return false, err } return true, nil })
UnifierLazyLoadFunc unifier for lazyload func
var UnifierLazyLoader = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { l := NewLazyLoader() l.Assembler = a err := SetValue(rv, reflect.ValueOf(l)) if err != nil { return false, err } return true, nil })
UnifierLazyLoader unifier for lazy loader
var UnifierMap = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { iter, err := a.Part().Iter() if err != nil || iter == nil { return false, err } mv := reflect.MakeMap(rv.Type()) for iter != nil { miv := reflect.New(rv.Type().Elem()).Elem() _, err = a.Config().Unifiers.Unify(a.WithChild(iter.Part, iter.Step), miv) if err != nil { return false, err } mv.SetMapIndex(reflect.ValueOf(iter.Step.Interface()), miv) iter, err = iter.Next() if err != nil { return false, err } } err = SetValue(rv, mv) if err != nil { return false, err } return true, nil })
UnifierMap unifier for map field
var UnifierNumber = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { v, err := a.Part().Value() if err != nil { return false, err } av := reflect.ValueOf(v) switch av.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint64, reflect.Float32, reflect.Float64: if rv.Kind() == av.Kind() { err = SetValue(rv, av) if err != nil { return false, err } return true, nil } err = SetValue(rv, reflect.ValueOf(v).Convert(rv.Type())) if err != nil { return false, err } return true, nil } return false, nil })
UnifierNumber unifier for number field
var UnifierPtr = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { av, err := a.Part().Value() if err != nil { return false, err } if av == nil { return true, nil } v := reflect.New(rv.Type().Elem()) err = SetValue(rv, v) if err != nil { return false, err } return a.Config().Unifiers.Unify(a, rv.Elem()) })
UnifierPtr unifier for pointer
var UnifierSlice = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { iter, err := a.Part().Iter() if err != nil { return false, err } if iter == nil { return false, nil } sv := reflect.MakeSlice(rv.Type(), 0, 0) for iter != nil { if iter.Step.Type() == TypeArray { v := reflect.New(rv.Type().Elem()).Elem() _, err = a.Config().Unifiers.Unify(a.WithChild(iter.Part, iter.Step), v) if err != nil { return false, err } sv = reflect.Append(sv, v) } iter, err = iter.Next() if err != nil { return false, err } } err = SetValue(rv, sv) if err != nil { return false, err } return true, nil })
UnifierSlice unifier for slice field
var UnifierString = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { v, err := a.Part().Value() if err != nil { return false, err } s, ok := v.(string) if ok { err = SetValue(rv, reflect.ValueOf(s).Convert(rv.Type())) if err != nil { return false, err } return true, nil } if !a.Config().DisableConvertStringInterface { i, ok := v.(String) if ok { err = SetValue(rv, reflect.ValueOf(i)) if err != nil { return false, err } return true, nil } } return false, nil })
UnifierString unifier for string field
var UnifierStruct = UnifierFunc(func(a *Assembler, rv reflect.Value) (bool, error) { v, err := a.Part().Value() if err != nil { return false, err } if v == nil { return true, nil } sd := newStructData() sd.assembler = a ok, err := sd.LoadValues() if err != nil { return false, err } if ok == false { prv := reflect.Indirect(reflect.ValueOf(v)) if prv.Kind() != reflect.Struct { return false, nil } err = SetValue(rv, prv) if err != nil { return false, err } return true, nil } return sd.WalkStruct(rv) })
UnifierStruct unifier for struct
Functions ¶
func ConvertPathToString ¶
ConvertPathToString convert assembler path to dot spilted string
func InitCommon ¶
func InitCommon()
func LoadConfig ¶
LoadConfig load byte slice to data by given config loader. Return any error if raised
func NewAssemblerError ¶
NewAssemblerError create new assemble error
func NewLoader ¶
NewLoader create new data loader with given driver name and data Return loader and any error if raised
func RegisterConfigLoader ¶
func RegisterConfigLoader(name string, c *ConfigLoader)
Types ¶
type ArrayStep ¶
type ArrayStep int
ArrayStep arry step type
type Assembler ¶
type Assembler struct {
// contains filtered or unexported fields
}
Assembler data assembler struct
func (*Assembler) Assemble ¶
Assemble assemble data to given value. Return assemble result and any error if raised.
func (*Assembler) CheckType ¶
CheckType check given reflect type type. Return type and any error if raised.
func (*Assembler) WithConfig ¶
WithConfig create new assembler with given config
type AssemblerError ¶
type AssemblerError struct {
// contains filtered or unexported fields
}
AssemblerError assembler error with assembler info
func (*AssemblerError) Error ¶
func (e *AssemblerError) Error() string
Error show error with assembler info
type AssemblerLazyLoader ¶
type AssemblerLazyLoader struct {
Assembler *Assembler
}
AssemblerLazyLoader assembler lazy loader struct
func NewLazyLoader ¶
func NewLazyLoader() *AssemblerLazyLoader
NewLazyLoader create new assembler lazy loader
func (*AssemblerLazyLoader) LazyLoadConfig ¶
func (l *AssemblerLazyLoader) LazyLoadConfig(v interface{}) error
LazyLoadConfig lazeload data into interface. Return any error if raised
type Config ¶
type Config struct { //Checkers registered type checkers Checkers *TypeCheckers //Unifiers registered unifiers Unifiers *Unifiers //TagName tag name used when parsed. //Tag will not be parsed if set to empty string //Default value is config TagName string //TagLazyLoad tag for lazyload //Default value is lazyload TagLazyLoad string //TagAnonymous tag for anonymous //Default value is anonymous TagAnonymous string //TagParser func which parses tags with given config TagParser func(c *Config, value string) (*Tag, error) //CaseSensitive convert struct field in case sensitive mode. CaseSensitive bool //DisableConvertStringInterface disable convert String interface to string field DisableConvertStringInterface bool //DisableConvertNumber disable numver converting DisableConvertNumber bool //CachedTags cached struct field tags CachedTags sync.Map }
Config assembler config struct
type ConfigLoader ¶
type ConfigLoader struct { Assembler *Assembler // contains filtered or unexported fields }
func NewConfigLoader ¶
func NewConfigLoader() *ConfigLoader
func (*ConfigLoader) Load ¶
func (l *ConfigLoader) Load(data []byte, v interface{}) error
func (*ConfigLoader) SetAssemblerConfig ¶
func (l *ConfigLoader) SetAssemblerConfig(c *Config) *ConfigLoader
func (*ConfigLoader) SetParser ¶
func (l *ConfigLoader) SetParser(p Parser) *ConfigLoader
type FieldStep ¶
type FieldStep struct {
*reflect.StructField
}
FieldStep field step struct
func NewFieldStep ¶
func NewFieldStep(f *reflect.StructField) *FieldStep
NewFieldStep create new field step
type GroupedUnifiers ¶
GroupedUnifiers unifier map grouped by type
func DefaultCommonUnifiers ¶
func DefaultCommonUnifiers() *GroupedUnifiers
DefaultCommonUnifiers return default common unifiers
func NewGroupedUnifiers ¶
func NewGroupedUnifiers() *GroupedUnifiers
NewGroupedUnifiers create new unifiers.
func (*GroupedUnifiers) Append ¶
func (u *GroupedUnifiers) Append(tp Type, unifier Unifier) *GroupedUnifiers
Append append unifier to last by given type
func (*GroupedUnifiers) AppendWith ¶
func (u *GroupedUnifiers) AppendWith(unifiers *GroupedUnifiers) *GroupedUnifiers
AppendWith append with given unifiers
func (*GroupedUnifiers) Insert ¶
func (u *GroupedUnifiers) Insert(tp Type, unifier Unifier) *GroupedUnifiers
Insert insert unifier to first by given type
func (*GroupedUnifiers) InsertWith ¶
func (u *GroupedUnifiers) InsertWith(unifiers *GroupedUnifiers) *GroupedUnifiers
InsertWith insert with given unifiers
type InterfaceStep ¶
type InterfaceStep struct {
// contains filtered or unexported fields
}
InterfaceStep interface step struct
func NewInterfaceStep ¶
func NewInterfaceStep(i interface{}) *InterfaceStep
NewInterfaceStep create new interface step
func (*InterfaceStep) Int ¶
func (s *InterfaceStep) Int() (int, bool)
Int return step value as int and any error if rasied.
func (*InterfaceStep) Interface ¶
func (s *InterfaceStep) Interface() interface{}
Interface return step value as interface.
func (*InterfaceStep) String ¶
func (s *InterfaceStep) String() string
String return step value as string.
type LazyLoader ¶
type LazyLoader interface { //LazyLoad lazeload data into interface. //Return any error if raised LazyLoadConfig(v interface{}) error }
LazyLoader lazy loader interface
type LazyLoaderFunc ¶
type LazyLoaderFunc func(v interface{}) error
LazyLoaderFunc lazy loader func interface
type MapPart ¶
type MapPart struct {
// contains filtered or unexported fields
}
MapPart assembler interface map part struct
type Part ¶
type Part interface { //Iter return part iter. //Nil should be returned If part is not iterable. Iter() (*PartIter, error) //Value return part value as empty interface. //Shold only used when part is not iterable Value() (interface{}, error) }
Part part interface Part is object used to assembler struct data. Unmarshal driver should create part to unmarshal data with assembler
type PartIter ¶
type PartIter struct { //Step current iter step Step Step //Part current iter part Part Part //Next return next part iter and any error if rasied. //nil shold be returned if iter finished. Next func() (*PartIter, error) }
PartIter part iter struct
type Path ¶
type Path interface { //Join join step to path and return new path Join(Step) Path //Pop pop last step and parent path Pop() (Step, Path) }
Path assembler path interface
type Step ¶
type Step interface { Type() interface{} String() string Int() (int, bool) Interface() interface{} }
Step part iter step interface
type Steps ¶
type Steps struct {
// contains filtered or unexported fields
}
Steps steps list struct
type StringStep ¶
type StringStep string
StringStep type
func NewStringStep ¶
func NewStringStep(str string) *StringStep
NewStringStep create new string step.
func (*StringStep) Int ¶
func (s *StringStep) Int() (int, bool)
Int return step value as int and any error if rasied.
func (*StringStep) Interface ¶
func (s *StringStep) Interface() interface{}
Interface return step value as interface.
func (*StringStep) String ¶
func (s *StringStep) String() string
String return step value as string.
type Tag ¶
type Tag struct { //Name parsed name tag Name string //Flags field flags Flags map[string]string //Ignored field ignored flag Ignored bool }
Tag struct field tag struct
type TypeChecker ¶
type TypeCheckers ¶
type TypeCheckers []TypeChecker
TypeCheckers type checkers list in order type
func DefaultCommonTypeCheckers ¶
func DefaultCommonTypeCheckers() *TypeCheckers
DefaultCommonTypeCheckers default common type checkers
func NewTypeCheckers ¶
func NewTypeCheckers() *TypeCheckers
NewTypeCheckers create new type checkers
func (*TypeCheckers) Append ¶
func (c *TypeCheckers) Append(checkers ...TypeChecker) *TypeCheckers
Append append checkers to last of given type checker.
func (*TypeCheckers) AppendWith ¶
func (c *TypeCheckers) AppendWith(checkers *TypeCheckers) *TypeCheckers
AppendWith append with given TypeCheckers
func (*TypeCheckers) CheckType ¶
CheckType check type with given assembler and reflect type. Return type and any error if raised.
func (*TypeCheckers) Insert ¶
func (c *TypeCheckers) Insert(checkers ...TypeChecker) *TypeCheckers
Insert insert checkers to first of given type checker.
func (*TypeCheckers) InsertWith ¶
func (c *TypeCheckers) InsertWith(checkers *TypeCheckers) *TypeCheckers
InsertWith insert with given TypeCheckers
type Unifier ¶
type Unifier interface { //Unify unify value from assembler to reflect value //Return whether unify successed or any error rasied Unify(a *Assembler, rv reflect.Value) (bool, error) }
Unifier unifier interface
type UnifierFunc ¶
UnifierFunc unifier func type