Implement several useful interfaces.

- Implement JSON Marshaler/Unmarshaler.
- Implement Text Marshaler/Unmarshaler.
- Implement SQL Driver Valuer.
- Implement SQL Scanner.
- Change Value() to ID() to avoid clashes with SQL Driver Valuer.

Author: Bruno Albuquerque

enum.go

@@ -1,17 +1,34 @@
 package enum
 
 import (
+	"database/sql"
+	"database/sql/driver"
+	"encoding"
+	"encoding/json"
+	"fmt"
 	"reflect"
 
 	"golang.org/x/exp/constraints"
 )
 
-// Enum represents a named Enum that is associaterd with a value. Enum values
-// are auto-generated starting form 0 and monotonically increasing in
+// Enum represents a named Enum that is associaterd with an ID. Enum IDs
+// are auto-generated starting from 0 and monotonically increasing in
 // declaration order.
 type Enum[T constraints.Integer] interface {
 	Name() string
-	Value() T
+	ID() T
+
+	// JSON support.
+	json.Marshaler
+	json.Unmarshaler
+
+	// Text support.
+	encoding.TextMarshaler
+	encoding.TextUnmarshaler
+
+	// SQL support.
+	driver.Valuer
+	sql.Scanner
 
 	// Makes sure no external package can implement this interface.
 	unimplementable()
@@ -31,7 +48,7 @@ func getTypeName[T any]() string {
 	return tType.PkgPath() + "." + tType.Name()
 }
 
-// New returns a new Enum associated with the given name and type T. 
+// New returns a new Enum associated with the given name and type T.
 func New[T constraints.Integer](name string) Enum[T] {
 	typeName := getTypeName[T]()
 
@@ -48,20 +65,113 @@ func New[T constraints.Integer](name string) Enum[T] {
 }
 
 // internalEnum is the only concrete implementation of the Enum interface. It
-// holds the name and typed value.
-type internalEnum[T comparable] struct {
-	name  string
-	value T
+// holds the name and typed ID.
+type internalEnum[T constraints.Integer] struct {
+	name string
+	id   T
 }
 
 // Name returns the name associated with this Enum instance.
 func (e internalEnum[T]) Name() string {
 	return e.name
 }
 
-// Value returns the value associated with this Enum instance.
-func (e internalEnum[T]) Value() T {
-	return e.value
+// ID returns the numeric ID associated with this Enum instance.
+func (e internalEnum[T]) ID() T {
+	return e.id
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (e internalEnum[T]) MarshalJSON() ([]byte, error) {
+	return json.Marshal(e.Name())
+}
+
+func getIDForName[T constraints.Integer](name string) (T, error) {
+	typeName := getTypeName[T]()
+
+	var defaultID T
+
+	anySet, ok := setByTypeName[typeName]
+	if !ok {
+		return defaultID, fmt.Errorf("no enum set associated with type %s", typeName)
+	}
+
+	s := anySet.(*internalSet[T])
+
+	id, ok := s.ids[name]
+	if !ok {
+		return defaultID, fmt.Errorf("name %s could not be found in enum set for type %s", name, typeName)
+	}
+
+	return T(id), nil
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+func (e *internalEnum[T]) UnmarshalJSON(data []byte) error {
+	var name string
+	if err := json.Unmarshal(data, &name); err != nil {
+		return fmt.Errorf("source should be a string, got %s", data)
+	}
+
+	id, err := getIDForName[T](name)
+	if err != nil {
+		return err
+	}
+
+	e.name = name
+	e.id = T(id)
+
+	return nil
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+func (e internalEnum[T]) MarshalText() ([]byte, error) {
+	return []byte(e.Name()), nil
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+func (e *internalEnum[T]) UnmarshalText(text []byte) error {
+	name := string(text)
+
+	id, err := getIDForName[T](name)
+	if err != nil {
+		return err
+	}
+
+	e.name = name
+	e.id = T(id)
+
+	return nil
+}
+
+func (e internalEnum[T]) Value() (driver.Value, error) {
+	return e.Name(), nil
+}
+
+func (e *internalEnum[T]) Scan(value any) error {
+	if value == nil {
+		return nil
+	}
+
+	name, ok := value.(string)
+	if !ok {
+		bytes, ok := value.([]byte)
+		if !ok {
+			return fmt.Errorf("value is not a byte slice")
+		}
+
+		name = string(bytes[:])
+	}
+
+	id, err := getIDForName[T](name)
+	if err != nil {
+		return err
+	}
+
+	e.name = name
+	e.id = T(id)
+
+	return nil
 }
 
 // unimplementanle makes sure we implement the Enum interface.

enum_test.go

@@ -25,16 +25,16 @@ func acceptsRoleOnly(t *testing.T, role Enum[Role]) {
 	t.Log(role)
 }
 
-func acceptsRoleValueOnly(t *testing.T, value Role) {
-	t.Log(value)
+func acceptsRoleIDOnly(t *testing.T, id Role) {
+	t.Log(id)
 }
 
 func acceptsPermissionOnly(t *testing.T, permission Enum[Permission]) {
 	t.Log(permission)
 }
 
-func acceptsPermissionValueOnly(t *testing.T, value Permission) {
-	t.Log(value)
+func acceptsPermissionIDOnly(t *testing.T, id Permission) {
+	t.Log(id)
 }
 
 func TestEnum(t *testing.T) {
@@ -45,22 +45,22 @@ func TestEnum(t *testing.T) {
 
 	// acceptsRoleOnly(t, UnknownPermission) // compile error
 
-	acceptsRoleValueOnly(t, UnknownRole.Value())
-	acceptsRoleValueOnly(t, Admin.Value())
-	acceptsRoleValueOnly(t, User.Value())
-	acceptsRoleValueOnly(t, Guest.Value())
+	acceptsRoleIDOnly(t, UnknownRole.ID())
+	acceptsRoleIDOnly(t, Admin.ID())
+	acceptsRoleIDOnly(t, User.ID())
+	acceptsRoleIDOnly(t, Guest.ID())
 
-	// acceptsRoleValueOnly(t, UnknownPermission.Value()) // compile error
+	// acceptsRoleIDOnly(t, UnknownPermission.ID()) // compile error
 
 	acceptsPermissionOnly(t, UnknownPermission)
 	acceptsPermissionOnly(t, Read)
 	acceptsPermissionOnly(t, Write)
 
 	// acceptsPermissionOnly(t, UnknownRole) // compile error
 
-	acceptsPermissionValueOnly(t, UnknownPermission.Value())
-	acceptsPermissionValueOnly(t, Read.Value())
-	acceptsPermissionValueOnly(t, Write.Value())
+	acceptsPermissionIDOnly(t, UnknownPermission.ID())
+	acceptsPermissionIDOnly(t, Read.ID())
+	acceptsPermissionIDOnly(t, Write.ID())
 
-	// acceptsPermissionValueOnly(t, UnknownRole.Value()) // compile error
+	// acceptsPermissionIDOnly(t, UnknownRole.ID()) // compile error
 }

set.go

@@ -9,8 +9,8 @@ import (
 
 // internalSet collects all enums associated with a specific type T.
 type internalSet[T constraints.Integer] struct {
-	nextValue int64 // Atomically updated.
-	values    map[string]int64
+	nextID int64 // Atomically updated.
+	ids    map[string]int64
 }
 
 // newInternalSet returns a new empty set.
@@ -21,43 +21,43 @@ func newInternalSet[T constraints.Integer]() *internalSet[T] {
 	}
 }
 
-// Add adds a new enum with the given name to the set. The enum value is
+// Add adds a new enum with the given name to the set. The enum ID is
 // auto-generated based on the instantiation order of enums. This panics if
 // an attempt is made to add an enum with a name that already exists in the
 // set.
 func (s *internalSet[T]) Add(name string) Enum[T] {
-	if _, ok := s.values[name]; ok {
+	if _, ok := s.ids[name]; ok {
 		panic("duplicate name in set")
 	}
 
-	value := atomic.AddInt64(&s.nextValue, 1)
-	value--
+	id := atomic.AddInt64(&s.nextID, 1)
+	id--
 
 	// TODO(bga): Check for integer overflow as T might be any integer type
 	// 			  (say, int8).
 
-	s.values[name] = value
+	s.ids[name] = id
 
-	return internalEnum[T]{name: name, value: T(value)}
+	return &internalEnum[T]{name: name, id: T(id)}
 }
 
 // GetByName returns the Enum associated with the given name and type T.
-func (s internalSet[T]) GetByName(name string) (Enum[T], error) {
-	value, ok := s.values[name]
+func (s *internalSet[T]) GetByName(name string) (Enum[T], error) {
+	id, ok := s.ids[name]
 	if !ok {
 		return nil, fmt.Errorf("name %s could not be found in set", name)
 	}
 
-	return internalEnum[T]{name: name, value: T(value)}, nil
+	return &internalEnum[T]{name: name, id: T(id)}, nil
 }
 
-// GetByValue returns the Enum associated with the given value and type T.
-func (s internalSet[T]) GetByValue(value int64) (Enum[T], error) {
-	for name, v := range s.values {
-		if v == value {
-			return internalEnum[T]{name: name, value: T(value)}, nil
+// GetByID returns the Enum associated with the given ID and type T.
+func (s *internalSet[T]) GetByID(id T) (Enum[T], error) {
+	for name, v := range s.ids {
+		if v == int64(id) {
+			return &internalEnum[T]{name: name, id: T(id)}, nil
 		}
 	}
 
-	return nil, fmt.Errorf("value %d could not be found in set", value)
+	return nil, fmt.Errorf("id %d could not be found in set", id)
 }