fq/pkg/scalar/scalar_gen.go.tmpl

// Code below generated from scalar_gen.go.tmpl
package scalar

import (
	"fmt"
	"math/big"

	"github.com/wader/fq/pkg/bitio"
)

{{- range $name, $t := $.types }}
	// Type {{$name}}

	// Actual{{$name}} asserts actual value is a {{$name}} and returns it
	func (s S) Actual{{$name}}() {{$t.go_type}} {
		v, ok := s.Actual.({{$t.go_type}})
		if !ok {
			panic(fmt.Sprintf("failed to type assert s.Actual %v as {{$t.go_type}}", s.Actual))
		}
		return v
	}

	// Actual{{$name}}Fn map actual {{$name}} using f
	type Actual{{$name}}Fn func(a {{$t.go_type}}) {{$t.go_type}}

	func (fn Actual{{$name}}Fn) MapScalar(s S) (S, error) {
		s.Actual = fn(s.Actual{{$name}}())
		return s, nil
	}

	// Sym{{$name}} asserts symbolic value is a {{$name}} and returns it
	func (s S) Sym{{$name}}() {{$t.go_type}} {
		v, ok := s.Sym.({{$t.go_type}})
		if !ok {
			panic(fmt.Sprintf("failed to type assert s.Sym %v as {{$t.go_type}}", s.Sym))
		}
		return v
	}

	// Sym{{$name}}Fn map sym {{$name}} using f
	type Sym{{$name}}Fn func(a {{$t.go_type}}) {{$t.go_type}}

	func (f Sym{{$name}}Fn) MapScalar(s S) (S, error) {
		s.Sym = f(s.Sym{{$name}}())
		return s, nil
	}
{{end}}

{{- range $from_name, $from := $.types }}
	{{- if ne $from.map_from false}}
		// Map {{$from_name}} -> Scalar
		type {{$from_name}}ToScalar map[{{$from.go_type}}]S
		func (m {{$from_name}}ToScalar) MapScalar(s S) (S, error) {
			a := s.Actual{{$from_name}}()
			if ns, ok := m[a]; ok {
				ns.Actual = a
				s = ns
			}
			return s, nil
		}

		// Map {{$from_name}} -> Description
		type {{$from_name}}ToDescription map[{{$from.go_type}}]string
		func (m {{$from_name}}ToDescription) MapScalar(s S) (S, error) {
			a := s.Actual{{$from_name}}()
			if d, ok := m[a]; ok {
				s.Description = d
			}
			return s, nil
		}

		{{- range $to_name, $to := $.types }}
			{{- if ne $to.map_to false}}
				// Map {{$from_name}} -> Sym {{$to_name}}
				type {{$from_name}}ToSym{{$to_name}} map[{{$from.go_type}}]{{$to.go_type}}
				func (m {{$from_name}}ToSym{{$to_name}}) MapScalar(s S) (S, error) {
					if t, ok := m[s.Actual{{$from_name}}()]; ok {
						s.Sym = t
					}
					return s, nil
				}
			{{- end}}
		{{- end}}
	{{- end}}
{{- end}}