1
1
mirror of https://github.com/wader/fq.git synced 2024-12-25 06:12:30 +03:00
fq/pkg/scalar/scalar_gen.go
Mattias Wadman 9b81d4d3ab decode: More type safe API and split scalar into multiple types
Preparation to make decoder use less memory and API more type safe.
Now each scalar type has it's own struct type so it can store different
things and enables to have a scalar interface.
Also own types will enable experimenting with decode DLS designs like
using chained methods that are type aware.
2022-12-14 16:23:58 +01:00

1865 lines
45 KiB
Go

// Code below generated from scalar_gen.go.tmpl
package scalar
import (
"fmt"
"math/big"
"github.com/wader/fq/pkg/bitio"
)
// Type Any
// does not use embedding for common fields as it works poorly with struct literals
type Any struct {
Sym any
Description string
Gap bool
Actual any
}
// interp.Scalarable
func (s Any) ScalarActual() any { return s.Actual }
func (s Any) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s Any) ScalarSym() any { return s.Sym }
func (s Any) ScalarDescription() string { return s.Description }
func (s Any) ScalarGap() bool { return s.Gap }
func (s Any) ScalarDisplayFormat() DisplayFormat { return 0 }
func AnyActual(v any) AnyMapper {
return AnyFn(func(s Any) (Any, error) { s.Actual = v; return s, nil })
}
func AnySym(v any) AnyMapper {
return AnyFn(func(s Any) (Any, error) { s.Sym = v; return s, nil })
}
func AnyDescription(v string) AnyMapper {
return AnyFn(func(s Any) (Any, error) { s.Description = v; return s, nil })
}
type AnyMapper interface {
MapAny(Any) (Any, error)
}
// AnyFn map actual Any using f
type AnyFn func(s Any) (Any, error)
func (fn AnyFn) MapAny(s Any) (Any, error) {
return fn(s)
}
// AnyActualFn map actual Any using f
type AnyActualFn func(a any) any
// TODO: error?
func (fn AnyActualFn) MapAny(s Any) (Any, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// AnySymFn map sym Any using f
type AnySymFn func(a any) any
func (f AnySymFn) MapAny(s Any) (Any, error) {
s.Sym = f(s.Sym)
return s, nil
}
// AnyDescriptionFn map sym Any using f
type AnyDescriptionFn func(a string) string
func (f AnyDescriptionFn) MapAny(s Any) (Any, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s Any) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s Any) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s Any) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s Any) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s Any) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s Any) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s Any) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s Any) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s Any) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s Any) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s Any) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s Any) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s Any) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s Any) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s Any) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s Any) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as any", s.Sym, s.Sym))
}
return v
}
// Type BigInt
// does not use embedding for common fields as it works poorly with struct literals
type BigInt struct {
Sym any
Description string
Gap bool
Actual *big.Int
DisplayFormat DisplayFormat
}
// interp.Scalarable
func (s BigInt) ScalarActual() any { return s.Actual }
func (s BigInt) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s BigInt) ScalarSym() any { return s.Sym }
func (s BigInt) ScalarDescription() string { return s.Description }
func (s BigInt) ScalarGap() bool { return s.Gap }
func (s BigInt) ScalarDisplayFormat() DisplayFormat { return s.DisplayFormat }
func BigIntActual(v *big.Int) BigIntMapper {
return BigIntFn(func(s BigInt) (BigInt, error) { s.Actual = v; return s, nil })
}
func BigIntSym(v any) BigIntMapper {
return BigIntFn(func(s BigInt) (BigInt, error) { s.Sym = v; return s, nil })
}
func BigIntDescription(v string) BigIntMapper {
return BigIntFn(func(s BigInt) (BigInt, error) { s.Description = v; return s, nil })
}
type BigIntMapper interface {
MapBigInt(BigInt) (BigInt, error)
}
// BigIntFn map actual BigInt using f
type BigIntFn func(s BigInt) (BigInt, error)
func (fn BigIntFn) MapBigInt(s BigInt) (BigInt, error) {
return fn(s)
}
// BigIntActualFn map actual BigInt using f
type BigIntActualFn func(a *big.Int) *big.Int
// TODO: error?
func (fn BigIntActualFn) MapBigInt(s BigInt) (BigInt, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// BigIntSymFn map sym BigInt using f
type BigIntSymFn func(a any) any
func (f BigIntSymFn) MapBigInt(s BigInt) (BigInt, error) {
s.Sym = f(s.Sym)
return s, nil
}
// BigIntDescriptionFn map sym BigInt using f
type BigIntDescriptionFn func(a string) string
func (f BigIntDescriptionFn) MapBigInt(s BigInt) (BigInt, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s BigInt) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s BigInt) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s BigInt) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s BigInt) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s BigInt) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s BigInt) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s BigInt) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s BigInt) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s BigInt) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s BigInt) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s BigInt) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s BigInt) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s BigInt) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s BigInt) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s BigInt) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s BigInt) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as *big.Int", s.Sym, s.Sym))
}
return v
}
// Type BitBuf
// does not use embedding for common fields as it works poorly with struct literals
type BitBuf struct {
Sym any
Description string
Gap bool
Actual bitio.ReaderAtSeeker
}
// interp.Scalarable
func (s BitBuf) ScalarActual() any { return s.Actual }
func (s BitBuf) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s BitBuf) ScalarSym() any { return s.Sym }
func (s BitBuf) ScalarDescription() string { return s.Description }
func (s BitBuf) ScalarGap() bool { return s.Gap }
func (s BitBuf) ScalarDisplayFormat() DisplayFormat { return 0 }
func BitBufActual(v bitio.ReaderAtSeeker) BitBufMapper {
return BitBufFn(func(s BitBuf) (BitBuf, error) { s.Actual = v; return s, nil })
}
func BitBufSym(v any) BitBufMapper {
return BitBufFn(func(s BitBuf) (BitBuf, error) { s.Sym = v; return s, nil })
}
func BitBufDescription(v string) BitBufMapper {
return BitBufFn(func(s BitBuf) (BitBuf, error) { s.Description = v; return s, nil })
}
type BitBufMapper interface {
MapBitBuf(BitBuf) (BitBuf, error)
}
// BitBufFn map actual BitBuf using f
type BitBufFn func(s BitBuf) (BitBuf, error)
func (fn BitBufFn) MapBitBuf(s BitBuf) (BitBuf, error) {
return fn(s)
}
// BitBufActualFn map actual BitBuf using f
type BitBufActualFn func(a bitio.ReaderAtSeeker) bitio.ReaderAtSeeker
// TODO: error?
func (fn BitBufActualFn) MapBitBuf(s BitBuf) (BitBuf, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// BitBufSymFn map sym BitBuf using f
type BitBufSymFn func(a any) any
func (f BitBufSymFn) MapBitBuf(s BitBuf) (BitBuf, error) {
s.Sym = f(s.Sym)
return s, nil
}
// BitBufDescriptionFn map sym BitBuf using f
type BitBufDescriptionFn func(a string) string
func (f BitBufDescriptionFn) MapBitBuf(s BitBuf) (BitBuf, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s BitBuf) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s BitBuf) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s BitBuf) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s BitBuf) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s BitBuf) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s BitBuf) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s BitBuf) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s BitBuf) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s BitBuf) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s BitBuf) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s BitBuf) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s BitBuf) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s BitBuf) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s BitBuf) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s BitBuf) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s BitBuf) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bitio.ReaderAtSeeker", s.Sym, s.Sym))
}
return v
}
// Type Bool
// does not use embedding for common fields as it works poorly with struct literals
type Bool struct {
Sym any
Description string
Gap bool
Actual bool
}
// interp.Scalarable
func (s Bool) ScalarActual() any { return s.Actual }
func (s Bool) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s Bool) ScalarSym() any { return s.Sym }
func (s Bool) ScalarDescription() string { return s.Description }
func (s Bool) ScalarGap() bool { return s.Gap }
func (s Bool) ScalarDisplayFormat() DisplayFormat { return 0 }
func BoolActual(v bool) BoolMapper {
return BoolFn(func(s Bool) (Bool, error) { s.Actual = v; return s, nil })
}
func BoolSym(v any) BoolMapper {
return BoolFn(func(s Bool) (Bool, error) { s.Sym = v; return s, nil })
}
func BoolDescription(v string) BoolMapper {
return BoolFn(func(s Bool) (Bool, error) { s.Description = v; return s, nil })
}
type BoolMapper interface {
MapBool(Bool) (Bool, error)
}
// BoolFn map actual Bool using f
type BoolFn func(s Bool) (Bool, error)
func (fn BoolFn) MapBool(s Bool) (Bool, error) {
return fn(s)
}
// BoolActualFn map actual Bool using f
type BoolActualFn func(a bool) bool
// TODO: error?
func (fn BoolActualFn) MapBool(s Bool) (Bool, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// BoolSymFn map sym Bool using f
type BoolSymFn func(a any) any
func (f BoolSymFn) MapBool(s Bool) (Bool, error) {
s.Sym = f(s.Sym)
return s, nil
}
// BoolDescriptionFn map sym Bool using f
type BoolDescriptionFn func(a string) string
func (f BoolDescriptionFn) MapBool(s Bool) (Bool, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s Bool) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s Bool) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s Bool) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s Bool) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s Bool) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s Bool) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s Bool) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s Bool) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s Bool) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s Bool) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s Bool) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s Bool) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s Bool) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s Bool) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s Bool) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s Bool) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as bool", s.Sym, s.Sym))
}
return v
}
// Type Flt
// does not use embedding for common fields as it works poorly with struct literals
type Flt struct {
Sym any
Description string
Gap bool
Actual float64
}
// interp.Scalarable
func (s Flt) ScalarActual() any { return s.Actual }
func (s Flt) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s Flt) ScalarSym() any { return s.Sym }
func (s Flt) ScalarDescription() string { return s.Description }
func (s Flt) ScalarGap() bool { return s.Gap }
func (s Flt) ScalarDisplayFormat() DisplayFormat { return 0 }
func FltActual(v float64) FltMapper {
return FltFn(func(s Flt) (Flt, error) { s.Actual = v; return s, nil })
}
func FltSym(v any) FltMapper {
return FltFn(func(s Flt) (Flt, error) { s.Sym = v; return s, nil })
}
func FltDescription(v string) FltMapper {
return FltFn(func(s Flt) (Flt, error) { s.Description = v; return s, nil })
}
type FltMapper interface {
MapFlt(Flt) (Flt, error)
}
// FltFn map actual Flt using f
type FltFn func(s Flt) (Flt, error)
func (fn FltFn) MapFlt(s Flt) (Flt, error) {
return fn(s)
}
// FltActualFn map actual Flt using f
type FltActualFn func(a float64) float64
// TODO: error?
func (fn FltActualFn) MapFlt(s Flt) (Flt, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// FltSymFn map sym Flt using f
type FltSymFn func(a any) any
func (f FltSymFn) MapFlt(s Flt) (Flt, error) {
s.Sym = f(s.Sym)
return s, nil
}
// FltDescriptionFn map sym Flt using f
type FltDescriptionFn func(a string) string
func (f FltDescriptionFn) MapFlt(s Flt) (Flt, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s Flt) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s Flt) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s Flt) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s Flt) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s Flt) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s Flt) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s Flt) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s Flt) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s Flt) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s Flt) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s Flt) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s Flt) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s Flt) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s Flt) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s Flt) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s Flt) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as float64", s.Sym, s.Sym))
}
return v
}
// Type Sint
// does not use embedding for common fields as it works poorly with struct literals
type Sint struct {
Sym any
Description string
Gap bool
Actual int64
DisplayFormat DisplayFormat
}
// interp.Scalarable
func (s Sint) ScalarActual() any { return s.Actual }
func (s Sint) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s Sint) ScalarSym() any { return s.Sym }
func (s Sint) ScalarDescription() string { return s.Description }
func (s Sint) ScalarGap() bool { return s.Gap }
func (s Sint) ScalarDisplayFormat() DisplayFormat { return s.DisplayFormat }
func SintActual(v int64) SintMapper {
return SintFn(func(s Sint) (Sint, error) { s.Actual = v; return s, nil })
}
func SintSym(v any) SintMapper {
return SintFn(func(s Sint) (Sint, error) { s.Sym = v; return s, nil })
}
func SintDescription(v string) SintMapper {
return SintFn(func(s Sint) (Sint, error) { s.Description = v; return s, nil })
}
type SintMapper interface {
MapSint(Sint) (Sint, error)
}
// SintFn map actual Sint using f
type SintFn func(s Sint) (Sint, error)
func (fn SintFn) MapSint(s Sint) (Sint, error) {
return fn(s)
}
// SintActualFn map actual Sint using f
type SintActualFn func(a int64) int64
// TODO: error?
func (fn SintActualFn) MapSint(s Sint) (Sint, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// SintSymFn map sym Sint using f
type SintSymFn func(a any) any
func (f SintSymFn) MapSint(s Sint) (Sint, error) {
s.Sym = f(s.Sym)
return s, nil
}
// SintDescriptionFn map sym Sint using f
type SintDescriptionFn func(a string) string
func (f SintDescriptionFn) MapSint(s Sint) (Sint, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s Sint) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s Sint) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s Sint) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s Sint) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s Sint) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s Sint) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s Sint) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s Sint) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s Sint) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s Sint) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s Sint) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s Sint) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s Sint) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s Sint) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s Sint) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s Sint) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as int64", s.Sym, s.Sym))
}
return v
}
// Type Str
// does not use embedding for common fields as it works poorly with struct literals
type Str struct {
Sym any
Description string
Gap bool
Actual string
}
// interp.Scalarable
func (s Str) ScalarActual() any { return s.Actual }
func (s Str) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s Str) ScalarSym() any { return s.Sym }
func (s Str) ScalarDescription() string { return s.Description }
func (s Str) ScalarGap() bool { return s.Gap }
func (s Str) ScalarDisplayFormat() DisplayFormat { return 0 }
func StrActual(v string) StrMapper {
return StrFn(func(s Str) (Str, error) { s.Actual = v; return s, nil })
}
func StrSym(v any) StrMapper {
return StrFn(func(s Str) (Str, error) { s.Sym = v; return s, nil })
}
func StrDescription(v string) StrMapper {
return StrFn(func(s Str) (Str, error) { s.Description = v; return s, nil })
}
type StrMapper interface {
MapStr(Str) (Str, error)
}
// StrFn map actual Str using f
type StrFn func(s Str) (Str, error)
func (fn StrFn) MapStr(s Str) (Str, error) {
return fn(s)
}
// StrActualFn map actual Str using f
type StrActualFn func(a string) string
// TODO: error?
func (fn StrActualFn) MapStr(s Str) (Str, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// StrSymFn map sym Str using f
type StrSymFn func(a any) any
func (f StrSymFn) MapStr(s Str) (Str, error) {
s.Sym = f(s.Sym)
return s, nil
}
// StrDescriptionFn map sym Str using f
type StrDescriptionFn func(a string) string
func (f StrDescriptionFn) MapStr(s Str) (Str, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s Str) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s Str) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s Str) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s Str) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s Str) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s Str) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s Str) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s Str) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s Str) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s Str) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s Str) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s Str) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s Str) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s Str) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s Str) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s Str) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as string", s.Sym, s.Sym))
}
return v
}
// Type Uint
// does not use embedding for common fields as it works poorly with struct literals
type Uint struct {
Sym any
Description string
Gap bool
Actual uint64
DisplayFormat DisplayFormat
}
// interp.Scalarable
func (s Uint) ScalarActual() any { return s.Actual }
func (s Uint) ScalarValue() any {
if s.Sym != nil {
return s.Sym
}
return s.Actual
}
func (s Uint) ScalarSym() any { return s.Sym }
func (s Uint) ScalarDescription() string { return s.Description }
func (s Uint) ScalarGap() bool { return s.Gap }
func (s Uint) ScalarDisplayFormat() DisplayFormat { return s.DisplayFormat }
func UintActual(v uint64) UintMapper {
return UintFn(func(s Uint) (Uint, error) { s.Actual = v; return s, nil })
}
func UintSym(v any) UintMapper {
return UintFn(func(s Uint) (Uint, error) { s.Sym = v; return s, nil })
}
func UintDescription(v string) UintMapper {
return UintFn(func(s Uint) (Uint, error) { s.Description = v; return s, nil })
}
type UintMapper interface {
MapUint(Uint) (Uint, error)
}
// UintFn map actual Uint using f
type UintFn func(s Uint) (Uint, error)
func (fn UintFn) MapUint(s Uint) (Uint, error) {
return fn(s)
}
// UintActualFn map actual Uint using f
type UintActualFn func(a uint64) uint64
// TODO: error?
func (fn UintActualFn) MapUint(s Uint) (Uint, error) {
s.Actual = fn(s.Actual)
return s, nil
}
// UintSymFn map sym Uint using f
type UintSymFn func(a any) any
func (f UintSymFn) MapUint(s Uint) (Uint, error) {
s.Sym = f(s.Sym)
return s, nil
}
// UintDescriptionFn map sym Uint using f
type UintDescriptionFn func(a string) string
func (f UintDescriptionFn) MapUint(s Uint) (Uint, error) {
s.Description = f(s.Description)
return s, nil
}
// TrySymAny try assert symbolic value is a Any and return result
func (s Uint) TrySymAny() (any, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(any)
return v, ok
}
// SymAny asserts symbolic value is a Any and returns it
func (s Uint) SymAny() any {
v, ok := s.TrySymAny()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// TrySymBigInt try assert symbolic value is a BigInt and return result
func (s Uint) TrySymBigInt() (*big.Int, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(*big.Int)
return v, ok
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s Uint) SymBigInt() *big.Int {
v, ok := s.TrySymBigInt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// TrySymBitBuf try assert symbolic value is a BitBuf and return result
func (s Uint) TrySymBitBuf() (bitio.ReaderAtSeeker, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bitio.ReaderAtSeeker)
return v, ok
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s Uint) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.TrySymBitBuf()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// TrySymBool try assert symbolic value is a Bool and return result
func (s Uint) TrySymBool() (bool, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(bool)
return v, ok
}
// SymBool asserts symbolic value is a Bool and returns it
func (s Uint) SymBool() bool {
v, ok := s.TrySymBool()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// TrySymFlt try assert symbolic value is a Flt and return result
func (s Uint) TrySymFlt() (float64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(float64)
return v, ok
}
// SymFlt asserts symbolic value is a Flt and returns it
func (s Uint) SymFlt() float64 {
v, ok := s.TrySymFlt()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// TrySymSint try assert symbolic value is a Sint and return result
func (s Uint) TrySymSint() (int64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(int64)
return v, ok
}
// SymSint asserts symbolic value is a Sint and returns it
func (s Uint) SymSint() int64 {
v, ok := s.TrySymSint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// TrySymStr try assert symbolic value is a Str and return result
func (s Uint) TrySymStr() (string, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(string)
return v, ok
}
// SymStr asserts symbolic value is a Str and returns it
func (s Uint) SymStr() string {
v, ok := s.TrySymStr()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// TrySymUint try assert symbolic value is a Uint and return result
func (s Uint) TrySymUint() (uint64, bool) {
//nolint:gosimple,nolintlint
v, ok := s.Sym.(uint64)
return v, ok
}
// SymUint asserts symbolic value is a Uint and returns it
func (s Uint) SymUint() uint64 {
v, ok := s.TrySymUint()
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v (%T) as uint64", s.Sym, s.Sym))
}
return v
}
// Map Bool
type BoolMap map[bool]Bool
func (m BoolMap) MapBool(s Bool) (Bool, error) {
if ns, ok := m[s.Actual]; ok {
ns.Actual = s.Actual
return ns, nil
}
return s, nil
}
// Map Bool description
type BoolMapDescription map[bool]string
func (m BoolMapDescription) MapBool(s Bool) (Bool, error) {
if d, ok := m[s.Actual]; ok {
s.Description = d
}
return s, nil
}
// Map Bool sym Bool
type BoolMapSymBool map[bool]bool
func (m BoolMapSymBool) MapBool(s Bool) (Bool, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool sym Flt
type BoolMapSymFlt map[bool]float64
func (m BoolMapSymFlt) MapBool(s Bool) (Bool, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool sym Sint
type BoolMapSymSint map[bool]int64
func (m BoolMapSymSint) MapBool(s Bool) (Bool, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool sym Str
type BoolMapSymStr map[bool]string
func (m BoolMapSymStr) MapBool(s Bool) (Bool, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool sym Uint
type BoolMapSymUint map[bool]uint64
func (m BoolMapSymUint) MapBool(s Bool) (Bool, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Sint
type SintMap map[int64]Sint
func (m SintMap) MapSint(s Sint) (Sint, error) {
if ns, ok := m[s.Actual]; ok {
ns.Actual = s.Actual
return ns, nil
}
return s, nil
}
// Map Sint description
type SintMapDescription map[int64]string
func (m SintMapDescription) MapSint(s Sint) (Sint, error) {
if d, ok := m[s.Actual]; ok {
s.Description = d
}
return s, nil
}
// Map Sint sym Bool
type SintMapSymBool map[int64]bool
func (m SintMapSymBool) MapSint(s Sint) (Sint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Sint sym Flt
type SintMapSymFlt map[int64]float64
func (m SintMapSymFlt) MapSint(s Sint) (Sint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Sint sym Sint
type SintMapSymSint map[int64]int64
func (m SintMapSymSint) MapSint(s Sint) (Sint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Sint sym Str
type SintMapSymStr map[int64]string
func (m SintMapSymStr) MapSint(s Sint) (Sint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Sint sym Uint
type SintMapSymUint map[int64]uint64
func (m SintMapSymUint) MapSint(s Sint) (Sint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Str
type StrMap map[string]Str
func (m StrMap) MapStr(s Str) (Str, error) {
if ns, ok := m[s.Actual]; ok {
ns.Actual = s.Actual
return ns, nil
}
return s, nil
}
// Map Str description
type StrMapDescription map[string]string
func (m StrMapDescription) MapStr(s Str) (Str, error) {
if d, ok := m[s.Actual]; ok {
s.Description = d
}
return s, nil
}
// Map Str sym Bool
type StrMapSymBool map[string]bool
func (m StrMapSymBool) MapStr(s Str) (Str, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Str sym Flt
type StrMapSymFlt map[string]float64
func (m StrMapSymFlt) MapStr(s Str) (Str, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Str sym Sint
type StrMapSymSint map[string]int64
func (m StrMapSymSint) MapStr(s Str) (Str, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Str sym Str
type StrMapSymStr map[string]string
func (m StrMapSymStr) MapStr(s Str) (Str, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Str sym Uint
type StrMapSymUint map[string]uint64
func (m StrMapSymUint) MapStr(s Str) (Str, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Uint
type UintMap map[uint64]Uint
func (m UintMap) MapUint(s Uint) (Uint, error) {
if ns, ok := m[s.Actual]; ok {
ns.Actual = s.Actual
return ns, nil
}
return s, nil
}
// Map Uint description
type UintMapDescription map[uint64]string
func (m UintMapDescription) MapUint(s Uint) (Uint, error) {
if d, ok := m[s.Actual]; ok {
s.Description = d
}
return s, nil
}
// Map Uint sym Bool
type UintMapSymBool map[uint64]bool
func (m UintMapSymBool) MapUint(s Uint) (Uint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Uint sym Flt
type UintMapSymFlt map[uint64]float64
func (m UintMapSymFlt) MapUint(s Uint) (Uint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Uint sym Sint
type UintMapSymSint map[uint64]int64
func (m UintMapSymSint) MapUint(s Uint) (Uint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Uint sym Str
type UintMapSymStr map[uint64]string
func (m UintMapSymStr) MapUint(s Uint) (Uint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}
// Map Uint sym Uint
type UintMapSymUint map[uint64]uint64
func (m UintMapSymUint) MapUint(s Uint) (Uint, error) {
if t, ok := m[s.Actual]; ok {
s.Sym = t
}
return s, nil
}