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
Mattias Wadman 7c5215347d bitio,decode: Refactor bitio usage and make buffer slicing more correct
Remove bitio.Buffer layer. bitio.Buffer was a kitchen sink layer with helpers
now it's just a buffer and most functions have been moved to decode instead.

bitio package now only have primitive types and functions simialar to standard
library io and bytes packages.

Make nearly eveything internally use bitio.Bit* interfaces so that slicing work
correctly this will also make it possible to start experimenting with more
complicated silcing helpers, ex things like:
breplace(.header.bitrate; 123) to get a new buffer with bitrate changed.
2022-02-04 21:41:53 +01:00

422 lines
7.3 KiB
Go

// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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
}
// 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 -> 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 -> 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 -> 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 -> 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
}