goki.dev/laser@v0.1.34/testdata/enumgen.go

// Code generated by "enumgen"; DO NOT EDIT.

package testdata

import (
	"errors"
	"strconv"
	"strings"

	"goki.dev/enums"
)

var _FruitsValues = []Fruits{0, 1, 2, 3, 4, 5, 6}

// FruitsN is the highest valid value
// for type Fruits, plus one.
const FruitsN Fruits = 7

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the enumgen command to generate them again.
func _FruitsNoOp() {
	var x [1]struct{}
	_ = x[Apple-(0)]
	_ = x[Orange-(1)]
	_ = x[Peach-(2)]
	_ = x[Strawberry-(3)]
	_ = x[Blackberry-(4)]
	_ = x[Blueberry-(5)]
	_ = x[Apricot-(6)]
}

var _FruitsNameToValueMap = map[string]Fruits{
	`Apple`:      0,
	`apple`:      0,
	`Orange`:     1,
	`orange`:     1,
	`Peach`:      2,
	`peach`:      2,
	`Strawberry`: 3,
	`strawberry`: 3,
	`Blackberry`: 4,
	`blackberry`: 4,
	`Blueberry`:  5,
	`blueberry`:  5,
	`Apricot`:    6,
	`apricot`:    6,
}

var _FruitsDescMap = map[Fruits]string{
	0: ``,
	1: ``,
	2: ``,
	3: ``,
	4: ``,
	5: ``,
	6: ``,
}

var _FruitsMap = map[Fruits]string{
	0: `Apple`,
	1: `Orange`,
	2: `Peach`,
	3: `Strawberry`,
	4: `Blackberry`,
	5: `Blueberry`,
	6: `Apricot`,
}

// String returns the string representation
// of this Fruits value.
func (i Fruits) String() string {
	if str, ok := _FruitsMap[i]; ok {
		return str
	}
	return strconv.FormatInt(int64(i), 10)
}

// SetString sets the Fruits value from its
// string representation, and returns an
// error if the string is invalid.
func (i *Fruits) SetString(s string) error {
	if val, ok := _FruitsNameToValueMap[s]; ok {
		*i = val
		return nil
	}
	if val, ok := _FruitsNameToValueMap[strings.ToLower(s)]; ok {
		*i = val
		return nil
	}
	return errors.New(s + " is not a valid value for type Fruits")
}

// Int64 returns the Fruits value as an int64.
func (i Fruits) Int64() int64 {
	return int64(i)
}

// SetInt64 sets the Fruits value from an int64.
func (i *Fruits) SetInt64(in int64) {
	*i = Fruits(in)
}

// Desc returns the description of the Fruits value.
func (i Fruits) Desc() string {
	if str, ok := _FruitsDescMap[i]; ok {
		return str
	}
	return i.String()
}

// FruitsValues returns all possible values
// for the type Fruits.
func FruitsValues() []Fruits {
	return _FruitsValues
}

// Values returns all possible values
// for the type Fruits.
func (i Fruits) Values() []enums.Enum {
	res := make([]enums.Enum, len(_FruitsValues))
	for i, d := range _FruitsValues {
		res[i] = d
	}
	return res
}

// IsValid returns whether the value is a
// valid option for type Fruits.
func (i Fruits) IsValid() bool {
	_, ok := _FruitsMap[i]
	return ok
}

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Fruits) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Fruits) UnmarshalText(text []byte) error {
	return i.SetString(string(text))
}

var _FoodsValues = []Foods{7, 8, 9, 10}

// FoodsN is the highest valid value
// for type Foods, plus one.
const FoodsN Foods = 11

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the enumgen command to generate them again.
func _FoodsNoOp() {
	var x [1]struct{}
	_ = x[Bread-(7)]
	_ = x[Lettuce-(8)]
	_ = x[Cheese-(9)]
	_ = x[Meat-(10)]
}

var _FoodsNameToValueMap = map[string]Foods{
	`Bread`:   7,
	`bread`:   7,
	`Lettuce`: 8,
	`lettuce`: 8,
	`Cheese`:  9,
	`cheese`:  9,
	`Meat`:    10,
	`meat`:    10,
}

var _FoodsDescMap = map[Foods]string{
	7:  ``,
	8:  ``,
	9:  ``,
	10: ``,
}

var _FoodsMap = map[Foods]string{
	7:  `Bread`,
	8:  `Lettuce`,
	9:  `Cheese`,
	10: `Meat`,
}

// String returns the string representation
// of this Foods value.
func (i Foods) String() string {
	if str, ok := _FoodsMap[i]; ok {
		return str
	}
	return Fruits(i).String()
}

// SetString sets the Foods value from its
// string representation, and returns an
// error if the string is invalid.
func (i *Foods) SetString(s string) error {
	if val, ok := _FoodsNameToValueMap[s]; ok {
		*i = val
		return nil
	}
	if val, ok := _FoodsNameToValueMap[strings.ToLower(s)]; ok {
		*i = val
		return nil
	}
	return (*Fruits)(i).SetString(s)
}

// Int64 returns the Foods value as an int64.
func (i Foods) Int64() int64 {
	return int64(i)
}

// SetInt64 sets the Foods value from an int64.
func (i *Foods) SetInt64(in int64) {
	*i = Foods(in)
}

// Desc returns the description of the Foods value.
func (i Foods) Desc() string {
	if str, ok := _FoodsDescMap[i]; ok {
		return str
	}
	return Fruits(i).Desc()
}

// FoodsValues returns all possible values
// for the type Foods.
func FoodsValues() []Foods {
	es := FruitsValues()
	res := make([]Foods, len(es))
	for i, e := range es {
		res[i] = Foods(e)
	}
	res = append(res, _FoodsValues...)
	return res
}

// Values returns all possible values
// for the type Foods.
func (i Foods) Values() []enums.Enum {
	es := FruitsValues()
	les := len(es)
	res := make([]enums.Enum, les+len(_FoodsValues))
	for i, d := range es {
		res[i] = d
	}
	for i, d := range _FoodsValues {
		res[i+les] = d
	}
	return res
}

// IsValid returns whether the value is a
// valid option for type Foods.
func (i Foods) IsValid() bool {
	_, ok := _FoodsMap[i]
	if !ok {
		return Fruits(i).IsValid()
	}
	return ok
}

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Foods) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Foods) UnmarshalText(text []byte) error {
	return i.SetString(string(text))
}