enum

func All ¶

func All[Enum any]() []Enum

All returns a slice containing all enum values of a specific type.

func Finalize ¶

func Finalize[Enum any]() bool

Finalize prevents the creation of any new enum values for the current type.

func From ¶

func From[Enum any, P any](a P) (Enum, bool)

From returns the corresponding enum for a given representation, and whether it is valid.

func FromInt ¶

func FromInt[Enum any](i int) (Enum, bool)

FromInt returns the corresponding enum for a given int representation, and whether it is valid.

DEPRECATED: Use FromNumber instead.

func FromNumber ¶

func FromNumber[Enum any, N xreflect.Number](n N) (Enum, bool)

FromNumber returns the corresponding enum for a given number representation, and whether it is valid.

func FromString ¶

func FromString[Enum any](s string) (Enum, bool)

FromString returns the corresponding enum for a given string representation, and whether it is valid.

func IsValid ¶

func IsValid[Enum any](value Enum) bool

IsValid checks if an enum value is valid. It returns true if the enum value is valid, and false otherwise.

func Map ¶

func Map[Enum any](enum Enum, reprs ...any) Enum

Map associates an enum with its representations under strict rules:

• String enums map to themselves as the string representation; Stringer is also treated as a string representation if no string repr is found.
• Numeric enums map to themselves as the numeric representation; all primitive numeric types (ints, uints, floats) are treated as a single type.
• An enum cannot be mapped to multiple representations of the same type.

Note that this function is not thread-safe and should only be called during initialization or other safe execution points to avoid race conditions.

package main

import (
	"fmt"

	"github.com/anypine/enum"
)

func main() {
	type Role int

	// Define enum values for Role using iota.
	const (
		RoleUser Role = iota
		RoleAdmin
	)

	// Map string representations to enum values.
	var (
		_ = enum.Map(RoleUser, "user")
		_ = enum.Map(RoleAdmin, "admin")
		_ = enum.Finalize[Role]()
	)

	// Print all enum values.
	for _, e := range enum.All[Role]() {
		fmt.Println(enum.ToString(e))
	}

}

Output:

user
admin

func MarshalJSON ¶

func MarshalJSON[Enum any](value Enum) ([]byte, error)

MarshalJSON serializes an enum value into its string representation.

func MarshalXML ¶

func MarshalXML[Enum any](encoder *xml.Encoder, start xml.StartElement, enum Enum) error

MarshalXML converts enum to its string representation.

func MarshalYAML ¶

func MarshalYAML[Enum any](value Enum) (any, error)

MarshalYAML serializes an enum value into its string representation.

func MustFrom ¶

func MustFrom[Enum any, P any](a P) Enum

MustFrom returns the corresponding enum for a given representation. It returns the zero value of enum in case the representation is unknown.

func MustFromInt ¶

func MustFromInt[Enum any](i int) Enum

MustFromInt returns the corresponding enum for a given int representation.

It returns zero value if the enum value is invalid.

DEPRECATED: Use MustFromNumber instead.

func MustFromNumber ¶

func MustFromNumber[Enum any, N xreflect.Number](n N) Enum

MustFromNumber returns the corresponding enum for a given number representation.

It returns the zero value if the enum value is invalid.

func MustFromString ¶

func MustFromString[Enum any](s string) Enum

MustFromString returns the corresponding enum for a given string representation.

It returns zero value if the string does not correspond to a valid enum value.

func MustTo ¶

func MustTo[P, Enum any](enum Enum) P

MustTo returns the representation (the type is relied on P type parameter) for the given enum value. It returns zero value if the enum is invalid or the enum doesn't have any representation of type P.

func NameOf ¶

func NameOf[T any]() string

NameOf returns the name of the enum type. In case of this is an advanced enum provided by this library, this function returns the only underlying enum name, which differs from TrueNameOf.

For example:

NameOf[Role]()           = "Role"
NameOf[WrapEnum[role]]() = "Role"

func New ¶

func New[Enum any](reprs ...any) (enum Enum)

New creates a dynamic enum value then mapped to its representations. The Enum type must be a number, string, or supported enums (e.g WrapEnum, SafeEnum).

If the enum is

• Supported enum: the inner new function will be called to generate the enum value.
• Number: the numeric representation will be assigned to the enum value.
• String: the string representation will be assigned to the enum value.
• Other cases, panics.

Note that this function is not thread-safe and should only be called during initialization or other safe execution points to avoid race conditions.

package main

import (
	"fmt"

	"github.com/anypine/enum"
)

func main() {
	type Role int

	// Define enum values for Role.
	var (
		RoleUser  = enum.New[Role]("user")
		RoleAdmin = enum.New[Role]("admin")
		_         = enum.Finalize[Role]()
	)

	// Print the string representation of enum values.
	fmt.Println("string(RoleUser):", enum.ToString(RoleUser))
	fmt.Println("string(RoleAdmin):", enum.ToString(RoleAdmin))

	// Demonstrate converting string to enum value.
	fmt.Println(`enum("user"):`, enum.MustFromString[Role]("user"))
	fmt.Println(`enum("admin"):`, enum.MustFromString[Role]("admin"))

}

Output:

string(RoleUser): user
string(RoleAdmin): admin
enum("user"): 0
enum("admin"): 1

func NewExtended ¶

func NewExtended[T newableEnum](reprs ...any) (enum T)

NewExtended initializes an extended enum then mapped to its representations.

An extended enum follows this structure (the embedded Enum must be an anonymous field to inherit its built-in methods):

type role any
type Role struct { enum.SafeEnum[role] }

Note that this function is not thread-safe and should only be called during initialization or other safe execution points to avoid race conditions.

func ScanSQL ¶

func ScanSQL[Enum any](a any, value *Enum) error

ScanSQL deserializes a database value into an enum type.

func To ¶

func To[P, Enum any](enum Enum) (P, bool)

To returns the representation (the type is relied on P type parameter) for the given enum value. The latter returned value is false if the enum is invalid or the enum doesn't have any representation of type P.

func ToInt ¶

func ToInt[Enum any](enum Enum) int

ToInt returns the int representation for the given enum value. It returns the smallest value of int (math.MinInt32) for invalid enums.

DEPRECATED: This function returns math.MinInt32 for invalid enums, which may cause unexpected behavior. Use To() or MustTo() instead.

func ToString ¶

func ToString[Enum any](value Enum) string

ToString returns the string representation of the given enum value. It returns <nil> for invalid enums.

func TrueNameOf ¶

func TrueNameOf[T any]() string

TrueNameOf returns the name of the enum type. In case of this is an advanced enum provided by this library, this function returns the full name, which differs from NameOf.

For example:

TrueNameOf[Role]()           = "Role"
TrueNameOf[WrapEnum[role]]() = "WrapEnum[role]"

func UnmarshalJSON ¶

func UnmarshalJSON[Enum any](data []byte, t *Enum) (err error)

UnmarshalJSON deserializes a string representation of an enum value from JSON.

func UnmarshalXML ¶

func UnmarshalXML[Enum any](decoder *xml.Decoder, start xml.StartElement, enum *Enum) error

UnmarshalXML parses the string representation back into an enum.

func UnmarshalYAML ¶

func UnmarshalYAML[Enum any](value *yaml.Node, t *Enum) error

UnmarshalYAML deserializes a string representation of an enum value from YAML.

func ValueSQL ¶

func ValueSQL[Enum any](value Enum) (driver.Value, error)

ValueSQL serializes an enum into a database-compatible format.