measurement-system.enum.go

//////////////////////////////////////////////////////////////////
///                                                              /
///                          DO NOT EDIT                         /
///                                                              /
///              Manual changes will be overwritten.             /
///                                                              /
///        Generated by github.com/boundedinfinity/enumer        /
///                                                              /
//////////////////////////////////////////////////////////////////

package measurement

import (
	"database/sql/driver"
	"encoding/json"
	"encoding/xml"
	"fmt"
	"strings"
)

//////////////////////////////////////////////////////////////////
///                                                              /
///                             Type                             /
///                                                              /
//////////////////////////////////////////////////////////////////

type MeasurementSystem string

//////////////////////////////////////////////////////////////////
///                                                              /
///                    Stringer implemenation                    /
///                                                              /
//////////////////////////////////////////////////////////////////

func (t MeasurementSystem) String() string {
	return string(t)
}

//////////////////////////////////////////////////////////////////
///                                                              /
///             JSON marshal/unmarshal implemenation             /
///                                                              /
//////////////////////////////////////////////////////////////////

func (t MeasurementSystem) MarshalJSON() ([]byte, error) {
	return json.Marshal(string(t))
}

func (t *MeasurementSystem) UnmarshalJSON(data []byte) error {
	var s string

	if err := json.Unmarshal(data, &s); err != nil {
		return err
	}

	found, err := MeasurementSystems.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

//////////////////////////////////////////////////////////////////
///                                                              /
///             YAML marshal/unmarshal implemenation             /
///                                                              /
//////////////////////////////////////////////////////////////////

func (t MeasurementSystem) MarshalYAML() (interface{}, error) {
	return string(t), nil
}

func (t *MeasurementSystem) UnmarshalYAML(unmarshal func(interface{}) error) error {
	var s string

	if err := unmarshal(&s); err != nil {
		return err
	}

	found, err := MeasurementSystems.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

//////////////////////////////////////////////////////////////////
///                                                              /
///              XML marshal/unmarshal implemenation             /
///                                                              /
//////////////////////////////////////////////////////////////////

func (t MeasurementSystem) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	return e.EncodeElement(string(t), start)
}

func (t *MeasurementSystem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	var s string

	if err := d.DecodeElement(&s, &start); err != nil {
		return err
	}

	found, err := MeasurementSystems.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

//////////////////////////////////////////////////////////////////
///                                                              /
///              SQL marshal/unmarshal implemenation             /
///                                                              /
//////////////////////////////////////////////////////////////////

func (t MeasurementSystem) Value() (driver.Value, error) {
	return string(t), nil
}

func (t *MeasurementSystem) Scan(value interface{}) error {
	if value == nil {
		return MeasurementSystems.errf(value)
	}

	dv, err := driver.String.ConvertValue(value)

	if err != nil {
		return err
	}

	s, ok := dv.(string)

	if !ok {
		return MeasurementSystems.errf(value)
	}

	found, err := MeasurementSystems.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

//////////////////////////////////////////////////////////////////
///                                                              /
///                       Companion struct                       /
///                                                              /
//////////////////////////////////////////////////////////////////

var MeasurementSystems = measurementSystems{
	Err:      fmt.Errorf("invalid MeasurementSystem"),
	Invalid:  MeasurementSystem("invalid"),
	Metric:   MeasurementSystem("metric"),
	Imperial: MeasurementSystem("imperial"),
	Unitless: MeasurementSystem("unitless"),
}

type measurementSystems struct {
	Err      error
	errf     func(any, ...MeasurementSystem) error
	parseMap map[MeasurementSystem][]string
	Invalid  MeasurementSystem
	Metric   MeasurementSystem
	Imperial MeasurementSystem
	Unitless MeasurementSystem
}

func (t measurementSystems) Values() []MeasurementSystem {
	return []MeasurementSystem{
		MeasurementSystems.Metric,
		MeasurementSystems.Imperial,
		MeasurementSystems.Unitless,
	}
}

func (t measurementSystems) ParseFrom(v string, items ...MeasurementSystem) (MeasurementSystem, error) {
	var found MeasurementSystem
	var ok bool

	for _, item := range items {
		matchers, ok2 := t.parseMap[item]

		if !ok2 {
			continue
		}

		for _, matcher := range matchers {
			if v == matcher {
				found = item
				ok = true
				break
			}
		}

		if ok {
			break
		}
	}

	if !ok {
		return found, t.errf(v, items...)
	}

	return found, nil
}

func (t measurementSystems) Parse(v string) (MeasurementSystem, error) {
	return t.ParseFrom(v, t.Values()...)
}

func (t measurementSystems) IsFrom(v string, items ...MeasurementSystem) bool {
	_, err := t.ParseFrom(v, items...)
	return err == nil
}

func (t measurementSystems) Is(v string) bool {
	return t.IsFrom(v, t.Values()...)
}

//////////////////////////////////////////////////////////////////
///                                                              /
///                        Initialization                        /
///                                                              /
//////////////////////////////////////////////////////////////////

func init() {
	MeasurementSystems.parseMap = map[MeasurementSystem][]string{
		MeasurementSystems.Imperial: {"imperial", "Imperial"},
		MeasurementSystems.Metric:   {"metric", "Metric"},
		MeasurementSystems.Unitless: {"unitless", "Unitless"},
	}

	MeasurementSystems.errf = func(v any, items ...MeasurementSystem) error {
		var xs []string

		for _, item := range items {
			if x, ok := MeasurementSystems.parseMap[item]; ok {
				xs = append(xs, x...)
			}
		}

		return fmt.Errorf(
			"%w: %v is not one of %s",
			MeasurementSystems.Err,
			v,
			strings.Join(xs, ","),
		)
	}
}