1
1
mirror of https://github.com/wader/fq.git synced 2024-12-25 14:23:18 +03:00
fq/pkg/scalar/scalar_gen.go

554 lines
10 KiB
Go
Raw Normal View History

// Code below generated from scalar_gen.go.tmpl
package scalar
import (
"fmt"
"math/big"
"github.com/wader/fq/pkg/bitio"
)
// Type BigInt
// ActualBigInt asserts actual value is a BigInt and returns it
func (s S) ActualBigInt() *big.Int {
v, ok := s.Actual.(*big.Int)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Actual %v as *big.Int", s.Actual))
}
return v
}
// ActualBigIntFn map actual BigInt using f
type ActualBigIntFn func(a *big.Int) *big.Int
func (fn ActualBigIntFn) MapScalar(s S) (S, error) {
s.Actual = fn(s.ActualBigInt())
return s, nil
}
// SymBigInt asserts symbolic value is a BigInt and returns it
func (s S) SymBigInt() *big.Int {
v, ok := s.Sym.(*big.Int)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v as *big.Int", s.Sym))
}
return v
}
// SymBigIntFn map sym BigInt using f
type SymBigIntFn func(a *big.Int) *big.Int
func (f SymBigIntFn) MapScalar(s S) (S, error) {
s.Sym = f(s.SymBigInt())
return s, nil
}
// Type BitBuf
// ActualBitBuf asserts actual value is a BitBuf and returns it
func (s S) ActualBitBuf() bitio.ReaderAtSeeker {
v, ok := s.Actual.(bitio.ReaderAtSeeker)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Actual %v as bitio.ReaderAtSeeker", s.Actual))
}
return v
}
// ActualBitBufFn map actual BitBuf using f
type ActualBitBufFn func(a bitio.ReaderAtSeeker) bitio.ReaderAtSeeker
func (fn ActualBitBufFn) MapScalar(s S) (S, error) {
s.Actual = fn(s.ActualBitBuf())
return s, nil
}
// SymBitBuf asserts symbolic value is a BitBuf and returns it
func (s S) SymBitBuf() bitio.ReaderAtSeeker {
v, ok := s.Sym.(bitio.ReaderAtSeeker)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v as bitio.ReaderAtSeeker", s.Sym))
}
return v
}
// SymBitBufFn map sym BitBuf using f
type SymBitBufFn func(a bitio.ReaderAtSeeker) bitio.ReaderAtSeeker
func (f SymBitBufFn) MapScalar(s S) (S, error) {
s.Sym = f(s.SymBitBuf())
return s, nil
}
// Type Bool
// ActualBool asserts actual value is a Bool and returns it
func (s S) ActualBool() bool {
v, ok := s.Actual.(bool)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Actual %v as bool", s.Actual))
}
return v
}
// ActualBoolFn map actual Bool using f
type ActualBoolFn func(a bool) bool
func (fn ActualBoolFn) MapScalar(s S) (S, error) {
s.Actual = fn(s.ActualBool())
return s, nil
}
// SymBool asserts symbolic value is a Bool and returns it
func (s S) SymBool() bool {
v, ok := s.Sym.(bool)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v as bool", s.Sym))
}
return v
}
// SymBoolFn map sym Bool using f
type SymBoolFn func(a bool) bool
func (f SymBoolFn) MapScalar(s S) (S, error) {
s.Sym = f(s.SymBool())
return s, nil
}
// Type F
// ActualF asserts actual value is a F and returns it
func (s S) ActualF() float64 {
v, ok := s.Actual.(float64)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Actual %v as float64", s.Actual))
}
return v
}
// ActualFFn map actual F using f
type ActualFFn func(a float64) float64
func (fn ActualFFn) MapScalar(s S) (S, error) {
s.Actual = fn(s.ActualF())
return s, nil
}
// SymF asserts symbolic value is a F and returns it
func (s S) SymF() float64 {
v, ok := s.Sym.(float64)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v as float64", s.Sym))
}
return v
}
// SymFFn map sym F using f
type SymFFn func(a float64) float64
func (f SymFFn) MapScalar(s S) (S, error) {
s.Sym = f(s.SymF())
return s, nil
}
// Type S
// ActualS asserts actual value is a S and returns it
func (s S) ActualS() int64 {
v, ok := s.Actual.(int64)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Actual %v as int64", s.Actual))
}
return v
}
// ActualSFn map actual S using f
type ActualSFn func(a int64) int64
func (fn ActualSFn) MapScalar(s S) (S, error) {
s.Actual = fn(s.ActualS())
return s, nil
}
// SymS asserts symbolic value is a S and returns it
func (s S) SymS() int64 {
v, ok := s.Sym.(int64)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v as int64", s.Sym))
}
return v
}
// SymSFn map sym S using f
type SymSFn func(a int64) int64
func (f SymSFn) MapScalar(s S) (S, error) {
s.Sym = f(s.SymS())
return s, nil
}
// Type Str
// ActualStr asserts actual value is a Str and returns it
func (s S) ActualStr() string {
v, ok := s.Actual.(string)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Actual %v as string", s.Actual))
}
return v
}
// ActualStrFn map actual Str using f
type ActualStrFn func(a string) string
func (fn ActualStrFn) MapScalar(s S) (S, error) {
s.Actual = fn(s.ActualStr())
return s, nil
}
// SymStr asserts symbolic value is a Str and returns it
func (s S) SymStr() string {
v, ok := s.Sym.(string)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v as string", s.Sym))
}
return v
}
// SymStrFn map sym Str using f
type SymStrFn func(a string) string
func (f SymStrFn) MapScalar(s S) (S, error) {
s.Sym = f(s.SymStr())
return s, nil
}
// Type U
// ActualU asserts actual value is a U and returns it
func (s S) ActualU() uint64 {
v, ok := s.Actual.(uint64)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Actual %v as uint64", s.Actual))
}
return v
}
// ActualUFn map actual U using f
type ActualUFn func(a uint64) uint64
func (fn ActualUFn) MapScalar(s S) (S, error) {
s.Actual = fn(s.ActualU())
return s, nil
}
// SymU asserts symbolic value is a U and returns it
func (s S) SymU() uint64 {
v, ok := s.Sym.(uint64)
if !ok {
panic(fmt.Sprintf("failed to type assert s.Sym %v as uint64", s.Sym))
}
return v
}
// SymUFn map sym U using f
type SymUFn func(a uint64) uint64
func (f SymUFn) MapScalar(s S) (S, error) {
s.Sym = f(s.SymU())
return s, nil
}
// Map Bool -> Scalar
type BoolToScalar map[bool]S
func (m BoolToScalar) MapScalar(s S) (S, error) {
a := s.ActualBool()
if ns, ok := m[a]; ok {
ns.Actual = a
s = ns
}
return s, nil
}
// Map Bool -> Description
type BoolToDescription map[bool]string
func (m BoolToDescription) MapScalar(s S) (S, error) {
a := s.ActualBool()
if d, ok := m[a]; ok {
s.Description = d
}
return s, nil
}
// Map Bool -> Sym Bool
type BoolToSymBool map[bool]bool
func (m BoolToSymBool) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualBool()]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool -> Sym F
type BoolToSymF map[bool]float64
func (m BoolToSymF) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualBool()]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool -> Sym S
type BoolToSymS map[bool]int64
func (m BoolToSymS) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualBool()]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool -> Sym Str
type BoolToSymStr map[bool]string
func (m BoolToSymStr) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualBool()]; ok {
s.Sym = t
}
return s, nil
}
// Map Bool -> Sym U
type BoolToSymU map[bool]uint64
func (m BoolToSymU) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualBool()]; ok {
s.Sym = t
}
return s, nil
}
// Map S -> Scalar
type SToScalar map[int64]S
func (m SToScalar) MapScalar(s S) (S, error) {
a := s.ActualS()
if ns, ok := m[a]; ok {
ns.Actual = a
s = ns
}
return s, nil
}
// Map S -> Description
type SToDescription map[int64]string
func (m SToDescription) MapScalar(s S) (S, error) {
a := s.ActualS()
if d, ok := m[a]; ok {
s.Description = d
}
return s, nil
}
// Map S -> Sym Bool
type SToSymBool map[int64]bool
func (m SToSymBool) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualS()]; ok {
s.Sym = t
}
return s, nil
}
// Map S -> Sym F
type SToSymF map[int64]float64
func (m SToSymF) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualS()]; ok {
s.Sym = t
}
return s, nil
}
// Map S -> Sym S
type SToSymS map[int64]int64
func (m SToSymS) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualS()]; ok {
s.Sym = t
}
return s, nil
}
// Map S -> Sym Str
type SToSymStr map[int64]string
func (m SToSymStr) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualS()]; ok {
s.Sym = t
}
return s, nil
}
// Map S -> Sym U
type SToSymU map[int64]uint64
func (m SToSymU) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualS()]; ok {
s.Sym = t
}
return s, nil
}
// Map Str -> Scalar
type StrToScalar map[string]S
func (m StrToScalar) MapScalar(s S) (S, error) {
a := s.ActualStr()
if ns, ok := m[a]; ok {
ns.Actual = a
s = ns
}
return s, nil
}
// Map Str -> Description
type StrToDescription map[string]string
func (m StrToDescription) MapScalar(s S) (S, error) {
a := s.ActualStr()
if d, ok := m[a]; ok {
s.Description = d
}
return s, nil
}
// Map Str -> Sym Bool
type StrToSymBool map[string]bool
func (m StrToSymBool) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualStr()]; ok {
s.Sym = t
}
return s, nil
}
// Map Str -> Sym F
type StrToSymF map[string]float64
func (m StrToSymF) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualStr()]; ok {
s.Sym = t
}
return s, nil
}
// Map Str -> Sym S
type StrToSymS map[string]int64
func (m StrToSymS) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualStr()]; ok {
s.Sym = t
}
return s, nil
}
// Map Str -> Sym Str
type StrToSymStr map[string]string
func (m StrToSymStr) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualStr()]; ok {
s.Sym = t
}
return s, nil
}
// Map Str -> Sym U
type StrToSymU map[string]uint64
func (m StrToSymU) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualStr()]; ok {
s.Sym = t
}
return s, nil
}
// Map U -> Scalar
type UToScalar map[uint64]S
func (m UToScalar) MapScalar(s S) (S, error) {
a := s.ActualU()
if ns, ok := m[a]; ok {
ns.Actual = a
s = ns
}
return s, nil
}
// Map U -> Description
type UToDescription map[uint64]string
func (m UToDescription) MapScalar(s S) (S, error) {
a := s.ActualU()
if d, ok := m[a]; ok {
s.Description = d
}
return s, nil
}
// Map U -> Sym Bool
type UToSymBool map[uint64]bool
func (m UToSymBool) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualU()]; ok {
s.Sym = t
}
return s, nil
}
// Map U -> Sym F
type UToSymF map[uint64]float64
func (m UToSymF) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualU()]; ok {
s.Sym = t
}
return s, nil
}
// Map U -> Sym S
type UToSymS map[uint64]int64
func (m UToSymS) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualU()]; ok {
s.Sym = t
}
return s, nil
}
// Map U -> Sym Str
type UToSymStr map[uint64]string
func (m UToSymStr) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualU()]; ok {
s.Sym = t
}
return s, nil
}
// Map U -> Sym U
type UToSymU map[uint64]uint64
func (m UToSymU) MapScalar(s S) (S, error) {
if t, ok := m[s.ActualU()]; ok {
s.Sym = t
}
return s, nil
}