measurement-format-type.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 MeasurementFormatType string

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

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

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

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

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

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

	found, err := MeasurementFormatTypes.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

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

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

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

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

	found, err := MeasurementFormatTypes.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

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

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

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

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

	found, err := MeasurementFormatTypes.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

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

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

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

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

	if err != nil {
		return err
	}

	s, ok := dv.(string)

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

	found, err := MeasurementFormatTypes.Parse(s)

	if err != nil {
		return err
	}

	*t = found
	return nil
}

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

var MeasurementFormatTypes = measurementFormatTypes{
	Err:          fmt.Errorf("invalid MeasurementFormatType"),
	Invalid:      MeasurementFormatType("invalid"),
	Full:         MeasurementFormatType("full"),
	Abbreviation: MeasurementFormatType("abbreviation"),
}

type measurementFormatTypes struct {
	Err          error
	errf         func(any, ...MeasurementFormatType) error
	parseMap     map[MeasurementFormatType][]string
	Invalid      MeasurementFormatType
	Full         MeasurementFormatType
	Abbreviation MeasurementFormatType
}

func (t measurementFormatTypes) Values() []MeasurementFormatType {
	return []MeasurementFormatType{
		MeasurementFormatTypes.Full,
		MeasurementFormatTypes.Abbreviation,
	}
}

func (t measurementFormatTypes) ParseFrom(v string, items ...MeasurementFormatType) (MeasurementFormatType, error) {
	var found MeasurementFormatType
	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 measurementFormatTypes) Parse(v string) (MeasurementFormatType, error) {
	return t.ParseFrom(v, t.Values()...)
}

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

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

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

func init() {
	MeasurementFormatTypes.parseMap = map[MeasurementFormatType][]string{
		MeasurementFormatTypes.Abbreviation: {"abbreviation", "Abbreviation"},
		MeasurementFormatTypes.Full:         {"full", "Full"},
	}

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

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

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