daq

package module

Go to main page

Versions in this module

v0

v0.10.1

May 10, 2024

v0.10.0

Apr 19, 2024

v0.9.1

Jan 27, 2024

v0.9.0

Jan 14, 2024

v0.8.0

Jan 13, 2024

Changes in this version

+ var DefaultMerge = Merge

+ type Merge struct

+ Time Time

+ func (mrg *Merge) Merge(into, from any) (err error)

+ type Merger interface

+ MergeDaQ func(by *Merge, add any) error

v0.7.0

Jan 7, 2024

Changes in this version

+ func DictAnyOr(fallback DictAny) func(Result, error) DictAny

+ func Fallback[T any](conv func(any) (T, error), fallback T) func(Result, error) T

+ func MapAnyOr(fallback MapAny) func(Result, error) MapAny

+ func RecoverDaQ(err *error)

+ func SliceAnyOr(fallback SliceAny) func(Result, error) SliceAny

+ type ConvertError struct

+ Value any

+ func (e ConvertError[T]) Error() string

type DictAny

+ func AsDictAny(res Result, err error) (DictAny, error)

+ func ToDictAny(v any) (DictAny, error)

+ func (d DictAny) AsBool(name string) (bool, error)

+ func (d DictAny) AsComplex128(name string) (complex128, error)

+ func (d DictAny) AsComplex64(name string) (complex64, error)

+ func (d DictAny) AsDict(name string) (Dict, error)

+ func (d DictAny) AsDictAny(name string) (DictAny, error)

+ func (d DictAny) AsDuration(name string) (time.Duration, error)

+ func (d DictAny) AsFloat32(name string) (float32, error)

+ func (d DictAny) AsFloat64(name string) (float64, error)

+ func (d DictAny) AsInt(name string) (int, error)

+ func (d DictAny) AsInt16(name string) (int16, error)

+ func (d DictAny) AsInt32(name string) (int32, error)

+ func (d DictAny) AsInt64(name string) (int64, error)

+ func (d DictAny) AsInt8(name string) (int8, error)

+ func (d DictAny) AsMap(name string) (Map, error)

+ func (d DictAny) AsMapAny(name string) (MapAny, error)

+ func (d DictAny) AsSlice(name string) (Slice, error)

+ func (d DictAny) AsSliceAny(name string) (SliceAny, error)

+ func (d DictAny) AsString(name string) (string, error)

+ func (d DictAny) AsTime(name string) (time.Time, error)

+ func (d DictAny) AsUint(name string) (uint, error)

+ func (d DictAny) AsUint16(name string) (uint16, error)

+ func (d DictAny) AsUint32(name string) (uint32, error)

+ func (d DictAny) AsUint64(name string) (uint64, error)

+ func (d DictAny) AsUint8(name string) (uint8, error)

+ func (d DictAny) AsUintPtr(name string) (uintptr, error)

+ func (d DictAny) BoolOr(name string, fallback bool) bool

+ func (d DictAny) Complex128Or(name string, fallback complex128) complex128

+ func (d DictAny) Complex64Or(name string, fallback complex64) complex64

+ func (d DictAny) DurationOr(name string, fallback time.Duration) time.Duration

+ func (d DictAny) Float32Or(name string, fallback float32) float32

+ func (d DictAny) Float64Or(name string, fallback float64) float64

+ func (d DictAny) Int16Or(name string, fallback int16) int16

+ func (d DictAny) Int32Or(name string, fallback int32) int32

+ func (d DictAny) Int64Or(name string, fallback int64) int64

+ func (d DictAny) Int8Or(name string, fallback int8) int8

+ func (d DictAny) IntOr(name string, fallback int) int

+ func (d DictAny) StringOr(name string, fallback string) string

+ func (d DictAny) TimeOr(name string, fallback time.Time) time.Time

+ func (d DictAny) Uint16Or(name string, fallback uint16) uint16

+ func (d DictAny) Uint32Or(name string, fallback uint32) uint32

+ func (d DictAny) Uint64Or(name string, fallback uint64) uint64

+ func (d DictAny) Uint8Or(name string, fallback uint8) uint8

+ func (d DictAny) UintOr(name string, fallback uint) uint

+ func (d DictAny) UintPtrOr(name string, fallback uintptr) uintptr

type MapAny

+ func AsMapAny(res Result, err error) (MapAny, error)

+ func ToMapAny(v any) (MapAny, error)

+ func (m MapAny) AsBool(key any) (bool, error)

+ func (m MapAny) AsComplex128(key any) (complex128, error)

+ func (m MapAny) AsComplex64(key any) (complex64, error)

+ func (m MapAny) AsDict(key any) (Dict, error)

+ func (m MapAny) AsDictAny(key any) (DictAny, error)

+ func (m MapAny) AsDuration(key any) (time.Duration, error)

+ func (m MapAny) AsFloat32(key any) (float32, error)

+ func (m MapAny) AsFloat64(key any) (float64, error)

+ func (m MapAny) AsInt(key any) (int, error)

+ func (m MapAny) AsInt16(key any) (int16, error)

+ func (m MapAny) AsInt32(key any) (int32, error)

+ func (m MapAny) AsInt64(key any) (int64, error)

+ func (m MapAny) AsInt8(key any) (int8, error)

+ func (m MapAny) AsMap(key any) (Map, error)

+ func (m MapAny) AsMapAny(key any) (MapAny, error)

+ func (m MapAny) AsSlice(key any) (Slice, error)

+ func (m MapAny) AsSliceAny(key any) (SliceAny, error)

+ func (m MapAny) AsString(key any) (string, error)

+ func (m MapAny) AsTime(key any) (time.Time, error)

+ func (m MapAny) AsUint(key any) (uint, error)

+ func (m MapAny) AsUint16(key any) (uint16, error)

+ func (m MapAny) AsUint32(key any) (uint32, error)

+ func (m MapAny) AsUint64(key any) (uint64, error)

+ func (m MapAny) AsUint8(key any) (uint8, error)

+ func (m MapAny) AsUintPtr(key any) (uintptr, error)

+ func (m MapAny) BoolOr(key any, fallback bool) bool

+ func (m MapAny) Complex128Or(key any, fallback complex128) complex128

+ func (m MapAny) Complex64Or(key any, fallback complex64) complex64

+ func (m MapAny) DurationOr(key any, fallback time.Duration) time.Duration

+ func (m MapAny) Float32Or(key any, fallback float32) float32

+ func (m MapAny) Float64Or(key any, fallback float64) float64

+ func (m MapAny) Get(key any) (Result, error)

+ func (m MapAny) Int16Or(key any, fallback int16) int16

+ func (m MapAny) Int32Or(key any, fallback int32) int32

+ func (m MapAny) Int64Or(key any, fallback int64) int64

+ func (m MapAny) Int8Or(key any, fallback int8) int8

+ func (m MapAny) IntOr(key, fallback int) int

+ func (m MapAny) StringOr(key any, fallback string) string

+ func (m MapAny) TimeOr(key any, fallback time.Time) time.Time

+ func (m MapAny) Uint16Or(key any, fallback uint16) uint16

+ func (m MapAny) Uint32Or(key any, fallback uint32) uint32

+ func (m MapAny) Uint64Or(key any, fallback uint64) uint64

+ func (m MapAny) Uint8Or(key any, fallback uint8) uint8

+ func (m MapAny) UintOr(key any, fallback uint) uint

+ func (m MapAny) UintPtrOr(key any, fallback uintptr) uintptr

+ type Result struct

+ Value any

+ func NewResult(value any, missedSteps int) Result

+ func Query(data any, path ...any) (res Result, err error)

+ func (r Result) Missed() int

+ func (r Result) OK() bool

+ func (r Result) SplitPath(p []any) (done, missing []any)

type SliceAny

+ func AsSliceAny(res Result, err error) (SliceAny, error)

+ func ToSliceAny(v any) (SliceAny, error)

+ func (s SliceAny) AsBool(i int) (bool, error)

+ func (s SliceAny) AsComplex128(i int) (complex128, error)

+ func (s SliceAny) AsComplex64(i int) (complex64, error)

+ func (s SliceAny) AsDict(i int) (Dict, error)

+ func (s SliceAny) AsDictAny(i int) (DictAny, error)

+ func (s SliceAny) AsDuration(i int) (time.Duration, error)

+ func (s SliceAny) AsFloat32(i int) (float32, error)

+ func (s SliceAny) AsFloat64(i int) (float64, error)

+ func (s SliceAny) AsInt(i int) (int, error)

+ func (s SliceAny) AsInt16(i int) (int16, error)

+ func (s SliceAny) AsInt32(i int) (int32, error)

+ func (s SliceAny) AsInt64(i int) (int64, error)

+ func (s SliceAny) AsInt8(i int) (int8, error)

+ func (s SliceAny) AsMap(i int) (Map, error)

+ func (s SliceAny) AsMapAny(i int) (MapAny, error)

+ func (s SliceAny) AsSlice(i int) (Slice, error)

+ func (s SliceAny) AsSliceAny(i int) (SliceAny, error)

+ func (s SliceAny) AsString(i int) (string, error)

+ func (s SliceAny) AsTime(i int) (time.Time, error)

+ func (s SliceAny) AsUint(i int) (uint, error)

+ func (s SliceAny) AsUint16(i int) (uint16, error)

+ func (s SliceAny) AsUint32(i int) (uint32, error)

+ func (s SliceAny) AsUint64(i int) (uint64, error)

+ func (s SliceAny) AsUint8(i int) (uint8, error)

+ func (s SliceAny) AsUintPtr(i int) (uintptr, error)

+ func (s SliceAny) BoolOr(i int, fallback bool) bool

+ func (s SliceAny) Complex128Or(i int, fallback complex128) complex128

+ func (s SliceAny) Complex64Or(i int, fallback complex64) complex64

+ func (s SliceAny) DurationOr(i int, fallback time.Duration) time.Duration

+ func (s SliceAny) Float32Or(i int, fallback float32) float32

+ func (s SliceAny) Float64Or(i int, fallback float64) float64

+ func (s SliceAny) Int16Or(i int, fallback int16) int16

+ func (s SliceAny) Int32Or(i int, fallback int32) int32

+ func (s SliceAny) Int64Or(i int, fallback int64) int64

+ func (s SliceAny) Int8Or(i int, fallback int8) int8

+ func (s SliceAny) IntOr(i, fallback int) int

+ func (s SliceAny) StringOr(i int, fallback string) string

+ func (s SliceAny) TimeOr(i int, fallback time.Time) time.Time

+ func (s SliceAny) Uint16Or(i int, fallback uint16) uint16

+ func (s SliceAny) Uint32Or(i int, fallback uint32) uint32

+ func (s SliceAny) Uint64Or(i int, fallback uint64) uint64

+ func (s SliceAny) Uint8Or(i int, fallback uint8) uint8

+ func (s SliceAny) UintOr(i int, fallback uint) uint

+ func (s SliceAny) UintPtrOr(i int, fallback uintptr) uintptr

type Track

+ T []any

+ func QueryTrack(data any, path ...any) (t Track, err error)

+ func (t Track) Missed() int

+ func (t Track) OK() bool

+ func (t Track) SplitPath(p []any) (done, missing []any)

v0.6.0

Jan 6, 2024

Changes in this version

+ func Complex128Or(fallback complex128) func(any, Status, error) complex128

+ func Complex64Or(fallback complex64) func(any, Status, error) complex64

+ func Must[T any](res T, stat Status, err error) T

+ func ToComplex128(v any) (complex128, error)

+ func ToComplex64(v any) (complex64, error)

type DictAny

+ func (d DictAny) Get(name string) (any, Status, error)

+ func (d DictAny) GetOK(n string) (any, Status, error)

type MapAny

+ func (m MapAny) Key(key any) (any, Status, error)

+ func (m MapAny) KeyOK(k any) (any, Status, error)

+ type NotFound Status

+ func (e NotFound) Error() string

+ func (e NotFound) Is(err error) bool

type SliceAny

+ func (s SliceAny) Get(index int) (any, Status, error)

+ func (s SliceAny) GetOK(index int) (any, Status, error)

+ type Status int

+ func AsComplex128(v any, stat Status, err error) (complex128, Status, error)

+ func AsComplex64(v any, stat Status, err error) (complex64, Status, error)

+ func OK(res any, stat Status, err error) (any, Status, error)

+ func (s Status) OK() bool

+ func (s Status) SplitPath(p []any) (done, pending []any)

v0.5.1

Jan 4, 2024

v0.5.0

Jan 4, 2024

Changes in this version

+ func DeepEqual(lhs, rhs any) bool

+ func DeepEqualFunc(lhs, rhs any, eq func(any, any) bool) bool

+ func TestingDeepEqual(t testing.TB, lhs, rhs any) (diffCount int)

+ func TestingDeepEqualFunc(t testing.TB, lhs, rhs any, eq func(any, any) bool) (diffCount int)

type Alt

+ Or any

+ type CollectionTypeError struct

+ func (e CollectionTypeError) Error() string

+ func (e CollectionTypeError) Is(err error) bool

+ type Delta struct

+ AtomEqual func(lhs, rhs any) bool

+ OnLeftOnly func(path []any, key, val any) error

+ OnNotEqual func(path []any, left, right any) error

+ OnRightOnly func(path []any, key, val any) error

+ func (cmpr *Delta) Compare(l, r any) error

+ type FirstIdxOf []int

+ func (idxs FirstIdxOf) Step(data any) (res any, err error)

+ type FirstKeyOf []any

+ func (ns FirstKeyOf) Step(data any) (res any, err error)

type Track

+ func (t Track) Step(i int) any

v0.4.1

Jan 3, 2024

Changes in this version

+ func As[T any](conv func(any) (T, error)) func(any, error) (T, error)

+ func DictOr(fallback Dict) func(any, error) Dict

+ func Key(data, key any) (res any, err error)

+ func ToBool(v any) (bool, error)

+ func ToDuration(v any) (time.Duration, error)

+ func ToFloat32(v any) (float32, error)

+ func ToFloat64(v any) (float64, error)

+ func ToInt(v any) (int, error)

+ func ToInt16(v any) (int16, error)

+ func ToInt32(v any) (int32, error)

+ func ToInt64(v any) (int64, error)

+ func ToInt8(v any) (int8, error)

+ func ToString(v any) (string, error)

+ func ToTime(v any) (time.Time, error)

+ func ToUint(v any) (uint, error)

+ func ToUint16(v any) (uint16, error)

+ func ToUint32(v any) (uint32, error)

+ func ToUint64(v any) (uint64, error)

+ func ToUint8(v any) (uint8, error)

+ func ToUintPtr(v any) (uintptr, error)

+ type Dict interface

+ DaQEachKey func(do func(key string) error) error

+ DaQGet func(name string) (res any, err error)

+ func AsDict(v any, err error) (Dict, error)

+ func ToDict(v any) (Dict, error)

+ type DictAny map[string]any

+ func (d DictAny) DaQEachKey(do func(key string) error) error

+ func (d DictAny) DaQGet(n string) (any, error)

+ type IndexOutOfRange struct

+ I int

+ Max int

+ Min int

+ func (e IndexOutOfRange) Error() string

type Map

+ func ToMap(v any) (Map, error)

+ DaQEachKey func(do func(key any) error) error

+ DaQGet func(key any) (res any, err error)

+ type MapAny map[any]any

+ func (m MapAny) DaQEachKey(do func(key any) error) error

+ func (m MapAny) DaQGet(key any) (any, error)

type Slice

+ func ToSlice(v any) (Slice, error)

+ DaQGet func(index int) (res any, err error)

+ DaQLen func() int

+ type SliceAny []any

+ func (s SliceAny) DaQGet(i int) (any, error)

+ func (s SliceAny) DaQLen() int

type Time

+ func (t Time) To(v any) (time.Time, error)

+ type UnknownField string

+ func (e UnknownField) Error() string

+ type UnknownKey struct

+ func (e UnknownKey) Error() string

v0.3.0

Jan 2, 2024

Changes in this version

+ func StepEach(data any, do func(key, value any) error) error

v0.2.0

Jan 1, 2024

v0.1.0

Dec 30, 2023

Changes in this version

+ func AsBool(v any, err error) (bool, error)

+ func AsDuration(v any, err error) (time.Duration, error)

+ func AsFloat32(v any, err error) (float32, error)

+ func AsFloat64(v any, err error) (float64, error)

+ func AsInt(v any, err error) (int, error)

+ func AsInt16(v any, err error) (int16, error)

+ func AsInt32(v any, err error) (int32, error)

+ func AsInt64(v any, err error) (int64, error)

+ func AsInt8(v any, err error) (int8, error)

+ func AsString(v any, err error) (string, error)

+ func AsTime(v any, err error) (time.Time, error)

+ func AsUint(v any, err error) (uint, error)

+ func AsUint16(v any, err error) (uint16, error)

+ func AsUint32(v any, err error) (uint32, error)

+ func AsUint64(v any, err error) (uint64, error)

+ func AsUint8(v any, err error) (uint8, error)

+ func AsUintPtr(v any, err error) (uintptr, error)

+ func BoolOr(fallback bool) func(any, error) bool

+ func DurationOr(fallback time.Duration) func(any, error) time.Duration

+ func Field(data any, name string) (any, error)

+ func Float32Or(fallback float32) func(any, error) float32

+ func Float64Or(fallback float64) func(any, error) float64

+ func Get(data any, path ...any) (res any, err error)

+ func Index(data any, i int) (any, error)

+ func Int16Or(fallback int16) func(any, error) int16

+ func Int32Or(fallback int32) func(any, error) int32

+ func Int64Or(fallback int64) func(any, error) int64

+ func Int8Or(fallback int8) func(any, error) int8

+ func IntOr(fallback int) func(any, error) int

+ func MapIndex(data any, key reflect.Value) (any, error)

+ func MapOr(fallback Map) func(any, error) Map

+ func SliceOr(fallback Slice) func(any, error) Slice

+ func Step(data, step any) (any, error)

+ func StringOr(fallback string) func(any, error) string

+ func TimeOr(fallback time.Time) func(any, error) time.Time

+ func Uint16Or(fallback uint16) func(any, error) uint16

+ func Uint32Or(fallback uint32) func(any, error) uint32

+ func Uint64Or(fallback uint64) func(any, error) uint64

+ func Uint8Or(fallback uint8) func(any, error) uint8

+ func UintOr(fallback uint) func(any, error) uint

+ func UintPtrOr(fallback uintptr) func(any, error) uintptr

+ func Val[T any](assert func(any, error) (T, error), fallback T) func(v any, err error) T

+ type Alt struct

+ Fallback any

+ S any

+ func (a Alt) Step(data any) (any, error)

+ type FirstNameOf []string

+ func (ns FirstNameOf) Step(data any) (res any, err error)

+ type FirstOf []any

+ func (keys FirstOf) Step(data any) (res any, err error)

+ type Map map[string]any

+ func AsMap(v any, err error) (Map, error)

+ func (m Map) Get(n string) (any, error)

+ type NoValue struct

+ ForStep any

+ func (e NoValue) Error() string

+ type Slice []any

+ func AsSlice(v any, err error) (Slice, error)

+ func (s Slice) Get(i int) (any, error)

+ type StepError struct

+ Err error

+ N int

+ Step any

+ func (e StepError) Error() string

+ func (e StepError) Unwrap() error

+ type Stepper interface

+ Step func(data any) (any, error)

+ type Time string

+ func (t Time) As(v any, err error) (time.Time, error)

+ type Track []any

+ func GetTrack(data any, path ...any) (t Track, err error)

+ func (t Track) At(i int) any

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