mapitf

package

Go to main page

Versions in this module

v1

v1.2.2

Sep 10, 2024

Changes in this version

type BaseItfImpl

+ func (b *BaseItfImpl) SetAllAsMap() (orgVal interface{}, err error)

type BasicListItfImpl

+ func (m *BasicListItfImpl) SetAllAsMap() (orgVal interface{}, err error)

type ForeachItfImpl

+ func (m *ForeachItfImpl) SetAllAsMap() (orgVal interface{}, err error)

v1.2.1

Sep 9, 2024

Changes in this version

+ func Config() *conf.Conf

+ func Fr(ctx context.Context, itf interface{}) api.MapInterface

+ func FrWithChain(ctx context.Context, itf interface{}, iterChain *IterChain) api.MapInterface

type BaseItfImpl

+ Ctx context.Context

+ IterChain *IterChain

+ func (b *BaseItfImpl) IsDigit() (bool, error)

+ func (b *BaseItfImpl) IsDigitList() (bool, error)

+ func (b *BaseItfImpl) IsList() (bool, error)

+ func (b *BaseItfImpl) IsMap() (bool, error)

+ func (b *BaseItfImpl) IsMapStrItf() (bool, error)

+ func (b *BaseItfImpl) IsStr() (bool, error)

+ func (b *BaseItfImpl) IsStrList() (bool, error)

+ func (b *BaseItfImpl) New() api.MapInterface

+ func (b *BaseItfImpl) OrgVal() (interface{}, error)

+ func (b *BaseItfImpl) PrintPath() string

+ func (b *BaseItfImpl) SetAsMap(key interface{}) (orgVal interface{}, err error)

+ func (b *BaseItfImpl) SetMap(key interface{}, val interface{}) (orgVal interface{}, err error)

+ func (b *BaseItfImpl) ToListMap() ([]map[string]interface{}, error)

+ func (b *BaseItfImpl) ToListRune() ([]rune, error)

+ func (b *BaseItfImpl) ToRune() (rune, error)

+ func (b *BaseItfImpl) ToStruct(stc interface{}) (interface{}, error)

+ func (b *BaseItfImpl) Uniq() api.MapInterface

type BasicItf

+ WithIterChain func(iterChain *IterChain) BasicItf

type BasicItfImpl

+ func (m *BasicItfImpl) New() api.MapInterface

+ func (m *BasicItfImpl) OrgVal() (interface{}, error)

+ func (m *BasicItfImpl) WithIterChain(iterChain *IterChain) BasicItf

type BasicListItf

+ WithIterChain func(iterChain *IterChain) BasicListItf

type BasicListItfImpl

+ OriginVal interface{}

+ func (m *BasicListItfImpl) Exist(key interface{}) (interface{}, bool)

+ func (m *BasicListItfImpl) New() api.MapInterface

+ func (m *BasicListItfImpl) OrgVal() (interface{}, error)

+ func (m *BasicListItfImpl) SetAsMap(key interface{}) (orgVal interface{}, err error)

+ func (m *BasicListItfImpl) SetMap(key interface{}, val interface{}) (orgVal interface{}, err error)

+ func (m *BasicListItfImpl) WithIterChain(iterChain *IterChain) BasicListItf

+ type EntranceFuncDefine interface

+ Fr func(ctx context.Context, itf interface{}) api.MapInterface

+ From func(itf interface{}) api.MapInterface

type ForeachItf

+ WithIterChain func(iterChain *IterChain) ForeachItf

type ForeachItfImpl

+ func (m *ForeachItfImpl) ForEach(forFunc api.ForFunc) api.MapInterface

+ func (m *ForeachItfImpl) IsDigit() (bool, error)

+ func (m *ForeachItfImpl) IsDigitList() (bool, error)

+ func (m *ForeachItfImpl) IsList() (bool, error)

+ func (m *ForeachItfImpl) IsMap() (bool, error)

+ func (m *ForeachItfImpl) IsMapStrItf() (bool, error)

+ func (m *ForeachItfImpl) IsStr() (bool, error)

+ func (m *ForeachItfImpl) IsStrList() (bool, error)

+ func (m *ForeachItfImpl) New() api.MapInterface

+ func (m *ForeachItfImpl) PrintPath() string

+ func (m *ForeachItfImpl) SetAsMap(key interface{}) (orgVal interface{}, err error)

+ func (m *ForeachItfImpl) SetMap(key interface{}, val interface{}) (orgVal interface{}, err error)

+ func (m *ForeachItfImpl) ToListMap() ([]map[string]interface{}, error)

+ func (m *ForeachItfImpl) ToListRune() ([]int32, error)

+ func (m *ForeachItfImpl) ToStruct(out interface{}) (interface{}, error)

+ func (m *ForeachItfImpl) Uniq() api.MapInterface

+ func (m *ForeachItfImpl) WithIterChain(iterChain *IterChain) ForeachItf

+ type IterChain struct

+ func NewLinkedList(val interface{}) *IterChain

+ func (i *IterChain) Clone() *IterChain

+ func (i *IterChain) HeadVal() interface{}

+ func (i *IterChain) PushBack(val interface{})

+ func (i *IterChain) PushBackByIdx(idx int, val interface{})

+ func (i *IterChain) PushBackByKey(key, val interface{})

+ func (i *IterChain) ReplaceBack(val interface{})

+ func (i *IterChain) SetBackPreVal(val interface{}) error

+ type IterCtx struct

+ Idx int

+ Key interface{}

+ Val interface{}

+ func NewEnterIterCtx(val interface{}) *IterCtx

+ func NewIterCtx(key, val interface{}, idx int) *IterCtx

+ type MapAnyToItf interface

+ WithErr func(err itferr.MapItfErr) MapAnyToItf

+ WithIterChain func(iterChain *IterChain) MapAnyToItf

+ func NewMapAnyToItfImpl(ctx context.Context, m interface{}) MapAnyToItf

+ type MapAnyToItfImpl struct

+ OriginVal interface{}

+ func (m *MapAnyToItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapAnyToItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapAnyToItfImpl) New() api.MapInterface

+ func (m *MapAnyToItfImpl) OrgVal() (interface{}, error)

+ func (m *MapAnyToItfImpl) WithErr(err itferr.MapItfErr) MapAnyToItf

+ func (m *MapAnyToItfImpl) WithIterChain(iterChain *IterChain) MapAnyToItf

type MapListItf

+ WithIterChain func(iterChain *IterChain) MapListItf

type MapListItfImpl

+ OriginVal interface{}

+ func (m *MapListItfImpl) New() api.MapInterface

+ func (m *MapListItfImpl) OrgVal() (interface{}, error)

+ func (m *MapListItfImpl) WithIterChain(iterChain *IterChain) MapListItf

type MapStrItf

+ WithIterChain func(iterChain *IterChain) MapStrItf

type MapStrItfImpl

+ OriginVal map[string]interface{}

+ func (m *MapStrItfImpl) GetOne(key string) api.MapInterface

+ func (m *MapStrItfImpl) New() api.MapInterface

+ func (m *MapStrItfImpl) OrgVal() (interface{}, error)

+ func (m *MapStrItfImpl) WithIterChain(iterChain *IterChain) MapStrItf

v1.0.20

Nov 10, 2021

v1.0.19

Nov 9, 2021

Changes in this version

+ const EmptyDataType

+ const ListDataType

+ const MapDataType

+ func From(itf interface{}) api.MapInterface

+ type BaseItfImpl struct

+ Class string

+ IterLevel int

+ IterVal interface{}

+ ItfErr *itferr.MapItfError

+ func (b *BaseItfImpl) Exist(key interface{}) (interface{}, bool)

+ func (b *BaseItfImpl) ForEach(forFunc api.ForFunc) api.MapInterface

+ func (b *BaseItfImpl) Get(key interface{}) api.MapInterface

+ func (b *BaseItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (b *BaseItfImpl) GetByInterface(key interface{}) (itfVal interface{}, err *itferr.MapItfError)

+ func (b *BaseItfImpl) Index(index int) api.MapInterface

+ func (b *BaseItfImpl) ToBool() (bool, error)

+ func (b *BaseItfImpl) ToByte() ([]byte, error)

+ func (b *BaseItfImpl) ToFloat32() (float32, error)

+ func (b *BaseItfImpl) ToFloat64() (float64, error)

+ func (b *BaseItfImpl) ToInt() (int, error)

+ func (b *BaseItfImpl) ToInt32() (int32, error)

+ func (b *BaseItfImpl) ToInt64() (int64, error)

+ func (b *BaseItfImpl) ToList() ([]interface{}, error)

+ func (b *BaseItfImpl) ToListBool() ([]bool, error)

+ func (b *BaseItfImpl) ToListFloat32() ([]float32, error)

+ func (b *BaseItfImpl) ToListFloat64() ([]float64, error)

+ func (b *BaseItfImpl) ToListInt() ([]int, error)

+ func (b *BaseItfImpl) ToListInt32() ([]int32, error)

+ func (b *BaseItfImpl) ToListInt64() ([]int64, error)

+ func (b *BaseItfImpl) ToListStr() ([]string, error)

+ func (b *BaseItfImpl) ToListStrF() ([]string, error)

+ func (b *BaseItfImpl) ToListUint() ([]uint, error)

+ func (b *BaseItfImpl) ToListUint32() ([]uint32, error)

+ func (b *BaseItfImpl) ToListUint64() ([]uint64, error)

+ func (b *BaseItfImpl) ToMap() (map[string]interface{}, error)

+ func (b *BaseItfImpl) ToMapFloat32() (map[float32]interface{}, error)

+ func (b *BaseItfImpl) ToMapFloat32ToFloat32() (map[float32]float32, error)

+ func (b *BaseItfImpl) ToMapFloat64() (map[float64]interface{}, error)

+ func (b *BaseItfImpl) ToMapFloat64ToFloat64() (map[float64]float64, error)

+ func (b *BaseItfImpl) ToMapInt() (map[int]interface{}, error)

+ func (b *BaseItfImpl) ToMapInt32() (map[int32]interface{}, error)

+ func (b *BaseItfImpl) ToMapInt64() (map[int64]interface{}, error)

+ func (b *BaseItfImpl) ToMapInt64ToInt64() (map[int64]int64, error)

+ func (b *BaseItfImpl) ToMapIntToInt() (map[int]int, error)

+ func (b *BaseItfImpl) ToMapItf() (map[interface{}]interface{}, error)

+ func (b *BaseItfImpl) ToMapStrToStr() (map[string]string, error)

+ func (b *BaseItfImpl) ToMapUint() (map[uint]interface{}, error)

+ func (b *BaseItfImpl) ToMapUint32() (map[uint32]interface{}, error)

+ func (b *BaseItfImpl) ToMapUint64() (map[uint64]interface{}, error)

+ func (b *BaseItfImpl) ToStr() (string, error)

+ func (b *BaseItfImpl) ToUint() (uint, error)

+ func (b *BaseItfImpl) ToUint32() (uint32, error)

+ func (b *BaseItfImpl) ToUint64() (uint64, error)

+ func (b *BaseItfImpl) Val() (interface{}, error)

+ func (b *BaseItfImpl) Valid() bool

+ type BasicItf interface

+ type BasicItfImpl struct

+ OriginItf interface{}

+ func (m *BasicItfImpl) Get(key interface{}) api.MapInterface

+ func (m *BasicItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *BasicItfImpl) Index(index int) api.MapInterface

+ type BasicListItf interface

+ type BasicListItfImpl struct

+ OriginItf interface{}

+ func (m *BasicListItfImpl) Get(key interface{}) api.MapInterface

+ func (m *BasicListItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *BasicListItfImpl) Index(index int) api.MapInterface

+ type DataType string

+ type ExceptItf interface

+ func NewExceptItfImpl() ExceptItf

+ func NewExceptItfImplErr(err *itferr.MapItfError) ExceptItf

+ type ExceptItfImpl struct

+ func (e *ExceptItfImpl) Get(key interface{}) api.MapInterface

+ type ForeachItf interface

+ func NewForeachItfImpl(list []interface{}, m map[interface{}]interface{}) ForeachItf

+ type ForeachItfImpl struct

+ DataType DataType

+ ListItf []interface{}

+ MapItf map[interface{}]interface{}

+ func (m *ForeachItfImpl) Get(key interface{}) api.MapInterface

+ func (m *ForeachItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *ForeachItfImpl) Index(index int) api.MapInterface

+ func (m *ForeachItfImpl) ToList() ([]interface{}, error)

+ func (m *ForeachItfImpl) ToListBool() ([]bool, error)

+ func (m *ForeachItfImpl) ToListFloat32() ([]float32, error)

+ func (m *ForeachItfImpl) ToListFloat64() ([]float64, error)

+ func (m *ForeachItfImpl) ToListInt() ([]int, error)

+ func (m *ForeachItfImpl) ToListInt32() ([]int32, error)

+ func (m *ForeachItfImpl) ToListInt64() ([]int64, error)

+ func (m *ForeachItfImpl) ToListStr() ([]string, error)

+ func (m *ForeachItfImpl) ToListStrF() ([]string, error)

+ func (m *ForeachItfImpl) ToListUint() ([]uint, error)

+ func (m *ForeachItfImpl) ToListUint32() ([]uint32, error)

+ func (m *ForeachItfImpl) ToListUint64() ([]uint64, error)

+ func (m *ForeachItfImpl) ToMap() (map[string]interface{}, error)

+ func (m *ForeachItfImpl) ToMapFloat32() (map[float32]interface{}, error)

+ func (m *ForeachItfImpl) ToMapFloat32ToFloat32() (map[float32]float32, error)

+ func (m *ForeachItfImpl) ToMapFloat64() (map[float64]interface{}, error)

+ func (m *ForeachItfImpl) ToMapFloat64ToFloat64() (map[float64]float64, error)

+ func (m *ForeachItfImpl) ToMapInt() (map[int]interface{}, error)

+ func (m *ForeachItfImpl) ToMapInt32() (map[int32]interface{}, error)

+ func (m *ForeachItfImpl) ToMapInt64() (map[int64]interface{}, error)

+ func (m *ForeachItfImpl) ToMapInt64ToInt64() (map[int64]int64, error)

+ func (m *ForeachItfImpl) ToMapIntToInt() (map[int]int, error)

+ func (m *ForeachItfImpl) ToMapItf() (map[interface{}]interface{}, error)

+ func (m *ForeachItfImpl) ToMapStrToStr() (map[string]string, error)

+ func (m *ForeachItfImpl) ToMapUint() (map[uint]interface{}, error)

+ func (m *ForeachItfImpl) ToMapUint32() (map[uint32]interface{}, error)

+ func (m *ForeachItfImpl) ToMapUint64() (map[uint64]interface{}, error)

+ type ItfType interface

+ ByList func() MapListItf

+ ByMapFloat32 func() MapFloat32Itf

+ ByMapFloat64 func() MapFloat64Itf

+ ByMapInt func() MapIntItf

+ ByMapInt32 func() MapInt32Itf

+ ByMapInt64 func() MapInt64Itf

+ ByMapItfToItf func() MapInterfaceToItf

+ ByMapStr func() MapStrItf

+ ByMapUint func() MapUintItf

+ ByMapUint32 func() MapUint32Itf

+ ByMapUint64 func() MapUint64Itf

+ func NewItfTypeImpl(itf interface{}) ItfType

+ func NewItfTypeImplErr(itf interface{}, err *itferr.MapItfError) ItfType

+ type ItfTypeImpl struct

+ Err *itferr.MapItfError

+ Itf interface{}

+ func (i *ItfTypeImpl) ByList() MapListItf

+ func (i *ItfTypeImpl) ByMapFloat32() MapFloat32Itf

+ func (i *ItfTypeImpl) ByMapFloat64() MapFloat64Itf

+ func (i *ItfTypeImpl) ByMapInt() MapIntItf

+ func (i *ItfTypeImpl) ByMapInt32() MapInt32Itf

+ func (i *ItfTypeImpl) ByMapInt64() MapInt64Itf

+ func (i *ItfTypeImpl) ByMapItfToItf() MapInterfaceToItf

+ func (i *ItfTypeImpl) ByMapStr() MapStrItf

+ func (i *ItfTypeImpl) ByMapUint() MapUintItf

+ func (i *ItfTypeImpl) ByMapUint32() MapUint32Itf

+ func (i *ItfTypeImpl) ByMapUint64() MapUint64Itf

+ type MapFloat32Itf interface

+ WithErr func(err *itferr.MapItfError) MapFloat32Itf

+ func NewMapFloat32ItfImpl(m interface{}) MapFloat32Itf

+ type MapFloat32ItfImpl struct

+ OriginMap map[float32]interface{}

+ func (m *MapFloat32ItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapFloat32ItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapFloat32ItfImpl) WithErr(err *itferr.MapItfError) MapFloat32Itf

+ type MapFloat64Itf interface

+ WithErr func(err *itferr.MapItfError) MapFloat64Itf

+ func NewMapFloat64ItfImpl(m interface{}) MapFloat64Itf

+ type MapFloat64ItfImpl struct

+ OriginMap map[float64]interface{}

+ func (m *MapFloat64ItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapFloat64ItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapFloat64ItfImpl) WithErr(err *itferr.MapItfError) MapFloat64Itf

+ type MapInt32Itf interface

+ WithErr func(err *itferr.MapItfError) MapInt32Itf

+ func NewMapInt32ItfImpl(m interface{}) MapInt32Itf

+ type MapInt32ItfImpl struct

+ OriginMap map[int32]interface{}

+ func (m *MapInt32ItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapInt32ItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapInt32ItfImpl) WithErr(err *itferr.MapItfError) MapInt32Itf

+ type MapInt64Itf interface

+ WithErr func(err *itferr.MapItfError) MapInt64Itf

+ func NewMapInt64ItfImpl(m interface{}) MapInt64Itf

+ type MapInt64ItfImpl struct

+ OriginMap map[int64]interface{}

+ func (m *MapInt64ItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapInt64ItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapInt64ItfImpl) WithErr(err *itferr.MapItfError) MapInt64Itf

+ type MapIntItf interface

+ WithErr func(err *itferr.MapItfError) MapIntItf

+ func NewMapIntItfImpl(m interface{}) MapIntItf

+ type MapIntItfImpl struct

+ OriginMap map[int]interface{}

+ func (m *MapIntItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapIntItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapIntItfImpl) WithErr(err *itferr.MapItfError) MapIntItf

+ type MapInterfaceToItf interface

+ WithErr func(err *itferr.MapItfError) MapInterfaceToItf

+ func NewMapInterfaceToItfImpl(m interface{}) MapInterfaceToItf

+ type MapInterfaceToItfImpl struct

+ OriginMap map[interface{}]interface{}

+ func (m *MapInterfaceToItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapInterfaceToItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapInterfaceToItfImpl) WithErr(err *itferr.MapItfError) MapInterfaceToItf

+ type MapListItf interface

+ func NewBasicItfImpl(m interface{}) MapListItf

+ func NewBasicListItfImpl(m interface{}) MapListItf

+ func NewMapListItfImpl(m interface{}) MapListItf

+ type MapListItfImpl struct

+ OriginListItf []interface{}

+ func (m *MapListItfImpl) Index(index int) api.MapInterface

+ type MapStrItf interface

+ GetByPath func(keys ...string) MapStrItf

+ WithErr func(err *itferr.MapItfError) MapStrItf

+ func NewMapStrItfImpl(m interface{}) MapStrItf

+ type MapStrItfImpl struct

+ OriginMap map[string]interface{}

+ func (m *MapStrItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapStrItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapStrItfImpl) GetByPath(keys ...string) MapStrItf

+ func (m *MapStrItfImpl) WithErr(err *itferr.MapItfError) MapStrItf

+ type MapUint32Itf interface

+ WithErr func(err *itferr.MapItfError) MapUint32Itf

+ func NewMapUint32ItfImpl(m interface{}) MapUint32Itf

+ type MapUint32ItfImpl struct

+ OriginMap map[uint32]interface{}

+ func (m *MapUint32ItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapUint32ItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapUint32ItfImpl) WithErr(err *itferr.MapItfError) MapUint32Itf

+ type MapUint64Itf interface

+ WithErr func(err *itferr.MapItfError) MapUint64Itf

+ func NewMapUint64ItfImpl(m interface{}) MapUint64Itf

+ type MapUint64ItfImpl struct

+ OriginMap map[uint64]interface{}

+ func (m *MapUint64ItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapUint64ItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapUint64ItfImpl) WithErr(err *itferr.MapItfError) MapUint64Itf

+ type MapUintItf interface

+ WithErr func(err *itferr.MapItfError) MapUintItf

+ func NewMapUintItfImpl(m interface{}) MapUintItf

+ type MapUintItfImpl struct

+ OriginMap map[uint]interface{}

+ func (m *MapUintItfImpl) Get(key interface{}) api.MapInterface

+ func (m *MapUintItfImpl) GetAny(keys ...interface{}) api.MapInterface

+ func (m *MapUintItfImpl) WithErr(err *itferr.MapItfError) MapUintItf

+ type OneLevelMapImpl struct

+ OriginMap interface{}

+ func NewOneLevelMap(m interface{}) *OneLevelMapImpl

+ func (o *OneLevelMapImpl) Get(key interface{}) api.MapInterface

+ func (o *OneLevelMapImpl) GetAny(keys ...interface{}) api.MapInterface

+ type OneLevelMapItf interface

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL