loader

package
v0.0.0-...-44d8e33 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 1, 2021 License: MIT Imports: 6 Imported by: 1

README

loader 配置加载器

配置约定

所有的驱动只确保必须支持如下类型数据

  • bool
  • int
  • int64
  • float32
  • float64
  • string
  • 以上任一类型的slice
  • 以上任一类型的map[string]xxxx
  • 仅包含以上数据的结构及相应的slice,map[string]xxxx

对于其他的类型，驱动可以自发可以支持，但视为未定义行为。

支持的待解析解析类型

  • bool
  • int
  • int64
  • float32
  • float64
  • string
  • struct
  • slice
  • map
  • 通过tag指定的 LazyLoadFunc 懒读取函数
  • 通过tag指定的 LazyLoader 懒读取接口
  • interface{}

interface{} 解析出的数据取决于传入的Part的Iter字段的Step类型

  • 如果为nil,即不可遍历，解析为part的Value返回值
  • 如果为TypeArray，即数组对象，解析为[]interface{}
  • 如果为TypeString，解析为map[string]interface{}
  • 如果为TypeEmptyInterface ,解析为map[interface{}]interface{}

匿名字段规则

匿名字段的规则如下:

  • 如果字段的对象不是个结构体的话，当作非匿名字段处理，不继续向下判断。
  • 如果通过tag设置过name,强制当作子结构按设置的name处理，不继续向下判断。
  • 如果配置中的匿名标签设置不为空，同时通过tag指定为匿名字段，强制将字段的所有字段当成父结构的字段处理，不继续向下判断。
  • 如果通过字段名可以找到对应的子元素，当成子结构处理，不继续向下判断。
  • 其他情况将所有字段当成父结构的字段处理，不继续向下判断。

如果匿名字段还包含匿名字段的话，递归处理

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var CommonTypeCheckers = NewTypeCheckers().AppendWith(DefaultCommonTypeCheckers())

CommonTypeCheckers common type checkers used in NewCommonConfig

View Source 
var CommonUnifiers = NewGroupedUnifiers().AppendWith(DefaultCommonUnifiers())

CommonUnifiers common unifiers user in NewCommonConfig

View Source 
var EmptyAssembler = &Assembler{
	path: NewSteps(),
}

EmptyAssembler empty assembler

View Source 
var ErrConfigLoaderNotRegistered = errors.New("config loader not registered")

ErrConfigLoaderNotRegistered error raised when parser not registered.

View Source 
var ErrNotAssignable = errors.New("value is not assignable")

ErrNotAssignable err raseid when given value not assignable

View Source 
var ErrNotPtr = errors.New("value to load is not a pointer")

ErrNotPtr error raised when value to load is not a pointer

View Source 
var ErrNotSetable = errors.New("value cannot set")

ErrNotSetable err raised when value can not set

View Source 
var NopLazyLoadFunc = reflect.ValueOf(nopAssemblerLazyLoader.LazyLoadConfig)

NopLazyLoadFunc no op assembler lazy load func

View Source 
var NopLazyLoader = reflect.ValueOf(nopAssemblerLazyLoader)

NopLazyLoader no op assembler lazy loader

View Source 
var TypeArray = Type("loader.array")

TypeArray field type array

View Source 
var TypeBool = Type("loader.bool")

TypeBool field type bool

View Source 
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.

View Source 
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.

View Source 
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

View Source 
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

View Source 
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.

View Source 
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

View Source 
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.

View Source 
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.

View Source 
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

View Source 
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

View Source 
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.

View Source 
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.

View Source 
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

View Source 
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.

View Source 
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

View Source 
var TypeEmptyInterface = Type("loader.interface{}")

TypeEmptyInterface field type empty interface

View Source 
var TypeFloat32 = Type("loader.float32")

TypeFloat32 field type float32

View Source 
var TypeFloat64 = Type("loader.float64")

TypeFloat64 field type float64

View Source 
var TypeInt = Type("loader.int")

TypeInt filed type int

View Source 
var TypeInt16 = Type("loader.int16")

TypeInt16 field type int16

View Source 
var TypeInt64 = Type("loader.int64")

TypeInt64 field type int64

View Source 
var TypeInt8 = Type("loader.int8")

TypeInt8 field type int8

View Source 
var TypeLazyLoadFunc = Type("loader.lazyloadfunc")

TypeLazyLoadFunc field type lazyload func

View Source 
var TypeLazyLoader = Type("loader.lazyloader")

TypeLazyLoader field type lazyloader

View Source 
var TypeMap = Type("loader.map")

TypeMap field type map

View Source 
var TypePtr = Type("loader.*")

TypePtr field type pointer

View Source 
var TypeSlice = Type("loader.slice")

TypeSlice field type slice

View Source 
var TypeString = Type("loader.string")

TypeString field type string

View Source 
var TypeStruct = Type("loader.struct")

TypeStruct field type struct

View Source 
var TypeStructField = Type("loader.structFild")

TypeStructField field type struct field

View Source 
var TypeUint = Type("loader.uint")

TypeUint field type uint

View Source 
var TypeUint16 = Type("loader.uint16")

TypeUint16 field type uint16

View Source 
var TypeUint64 = Type("loader.uint64")

TypeUint64 field type uint64

View Source 
var TypeUint8 = Type("loader.uint8")

TypeUint8 field type uint8

View Source 
var TypeUnkonwn = Type("")

TypeUnkonwn field type unkowwn

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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

View Source 
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 

func ConvertPathToString(p Path) string

ConvertPathToString convert assembler path to dot spilted string

func InitCommon 

func InitCommon()

func LoadConfig 

func LoadConfig(name string, data []byte, v interface{}) error

LoadConfig load byte slice to data by given config loader. Return any error if raised

func NewAssemblerError 

func NewAssemblerError(a *Assembler, err error) error

NewAssemblerError create new assemble error

func NewLoader 

func NewLoader(name string, data []byte) func(v interface{}) error

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)

func SetValue 

func SetValue(dst, src reflect.Value) error

SetValue set src value to dst. return any error if rasied

Types

type ArrayStep 

type ArrayStep int

ArrayStep arry step type

func NewArrayStep 

func NewArrayStep(i int) *ArrayStep

NewArrayStep create new array step

func (*ArrayStep) Int 

func (s *ArrayStep) Int() (int, bool)

Int return step value as int and any error if rasied.

func (*ArrayStep) Interface 

func (s *ArrayStep) Interface() interface{}

Interface return step value as interface.

func (*ArrayStep) String 

func (s *ArrayStep) String() string

String return step value as string.

func (*ArrayStep) Type 

func (s *ArrayStep) Type() interface{}

Type return step type

type Assembler 

type Assembler struct {
	// contains filtered or unexported fields
}

Assembler data assembler struct

func (*Assembler) Assemble 

func (a *Assembler) Assemble(v interface{}) (ok bool, err error)

Assemble assemble data to given value. Return assemble result and any error if raised.

func (*Assembler) CheckType 

func (a *Assembler) CheckType(rv reflect.Value) (tp Type, err error)

CheckType check given reflect type type. Return type and any error if raised.

func (*Assembler) Config 

func (a *Assembler) Config() *Config

Config return assembler config

func (*Assembler) Part 

func (a *Assembler) Part() Part

Part return assembler part

func (*Assembler) Path 

func (a *Assembler) Path() Path

Path return assembler path

func (*Assembler) Step 

func (a *Assembler) Step() Step

Step return current assembler step

func (*Assembler) WithChild 

func (a *Assembler) WithChild(p Part, step Step) *Assembler

WithChild create assembler with given child part and step

func (*Assembler) WithConfig 

func (a *Assembler) WithConfig(c *Config) *Assembler

WithConfig create new assembler with given config

func (*Assembler) WithPart 

func (a *Assembler) WithPart(p Part) *Assembler

WithPart create new assembler with given part

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

func (*AssemblerError) Unwrap 

func (e *AssemblerError) Unwrap() error

Unwrap unwrap error

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 Checker 

type Checker struct {
	Type    Type
	Checker func(a *Assembler, rv reflect.Value) (bool, error)
}

func (*Checker) CheckType 

func (c *Checker) CheckType(a *Assembler, rv reflect.Value) (Type, error)

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

func NewCommonConfig 

func NewCommonConfig() *Config

NewCommonConfig create new common config

func NewConfig 

func NewConfig() *Config

NewConfig create new config.

func (*Config) GetTag 

func (c *Config) GetTag(structType reflect.Type, field reflect.StructField) (*Tag, error)

GetTag get tags for given reflect type and struct field. Return tag and any error if raised

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

func (*FieldStep) Int 

func (s *FieldStep) Int() (int, bool)

Int return step value as int and any error if rasied.

func (*FieldStep) Interface 

func (s *FieldStep) Interface() interface{}

Interface return step value as interface.

func (*FieldStep) String 

func (s *FieldStep) String() string

String return step value as string.

func (*FieldStep) Type 

func (s *FieldStep) Type() interface{}

Type return step type

type GroupedUnifiers 

type GroupedUnifiers map[Type][]Unifier

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

func (*GroupedUnifiers) Unify 

func (u *GroupedUnifiers) Unify(a *Assembler, rv reflect.Value) (bool, error)

Unify unify value from assembler to reflect value Return whether unify successed or any error rasied

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.

func (*InterfaceStep) Type 

func (s *InterfaceStep) Type() interface{}

Type return step type

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

func NewMapPart 

func NewMapPart(v interface{}) *MapPart

NewMapPart create new map part

func (*MapPart) Iter 

func (d *MapPart) Iter() (*PartIter, error)

Iter return part iter. Nil should be returned If part is not iterable.

func (*MapPart) Value 

func (d *MapPart) Value() (interface{}, error)

Value return part value as empty interface. Shold only used when part is not iterable

type Parser 

type Parser interface {
	Parse(data []byte) (Part, error)
}

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

func NewSteps 

func NewSteps() *Steps

NewSteps create new steps.

func (*Steps) Join 

func (s *Steps) Join(step Step) Path

Join join step to path and return new path

func (*Steps) Pop 

func (s *Steps) Pop() (Step, Path)

Pop pop last step and parent path

type String 

type String interface {
	String() string
}

String interface

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.

func (*StringStep) Type 

func (s *StringStep) Type() interface{}

Type return step type

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

func NewTag 

func NewTag() *Tag

NewTag create new tag struct

func ParseTag 

func ParseTag(c *Config, value string) (*Tag, error)

ParseTag default parse tag func Parse field tag with given config Return parsed tag and any error if rasised.

type Type 

type Type string

Type field type

type TypeChecker 

type TypeChecker interface {
	CheckType(a *Assembler, rv reflect.Value) (Type, error)
}

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 

func (c *TypeCheckers) CheckType(a *Assembler, rv reflect.Value) (Type, error)

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 

type UnifierFunc func(a *Assembler, rv reflect.Value) (bool, error)

UnifierFunc unifier func type

func (UnifierFunc) Unify 

func (f UnifierFunc) Unify(a *Assembler, rv reflect.Value) (bool, error)

Unify unify value from assembler to reflect value Return whether unify successed or any error rasied

type Unifiers 

type Unifiers []Unifier

func NewUnifiers 

func NewUnifiers() *Unifiers

func (*Unifiers) Append 

func (u *Unifiers) Append(unifier ...Unifier) *Unifiers

func (*Unifiers) Insert 

func (u *Unifiers) Insert(unifier ...Unifier) *Unifiers

func (*Unifiers) Unify 

func (u *Unifiers) Unify(a *Assembler, rv reflect.Value) (bool, error)

Source Files

View all Source files

Directories

Path Synopsis
drivers
jsonconfig
tomlconfig
types
timedurationtype

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.