From f8202df9aa232d6385383dc0edeb76da701c1f57 Mon Sep 17 00:00:00 2001 From: Hippolyte HENRY Date: Sun, 4 Apr 2021 11:32:17 +0200 Subject: [PATCH] [go] Add constructor and IsValid method to enum types (#8224) * Add constructor and IsValid method to enum types * Add samples --- .../src/main/resources/go/model_enum.mustache | 31 ++++++++++++++++++- .../go/go-petstore/model_enum_class.go | 29 ++++++++++++++++- .../go/go-petstore/model_outer_enum.go | 29 ++++++++++++++++- .../go/go-petstore/model_enum_class.go | 29 ++++++++++++++++- .../go/go-petstore/model_outer_enum.go | 29 ++++++++++++++++- .../model_outer_enum_default_value.go | 29 ++++++++++++++++- .../go-petstore/model_outer_enum_integer.go | 29 ++++++++++++++++- .../model_outer_enum_integer_default_value.go | 29 ++++++++++++++++- 8 files changed, 226 insertions(+), 8 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/go/model_enum.mustache b/modules/openapi-generator/src/main/resources/go/model_enum.mustache index 1d3c2244c098..11dfbfc7d334 100644 --- a/modules/openapi-generator/src/main/resources/go/model_enum.mustache +++ b/modules/openapi-generator/src/main/resources/go/model_enum.mustache @@ -12,6 +12,14 @@ const ( {{/allowableValues}} ) +var allowed{{{classname}}}EnumValues = []{{{classname}}}{ + {{#allowableValues}} + {{#enumVars}} + {{{value}}}, + {{/enumVars}} + {{/allowableValues}} +} + func (v *{{{classname}}}) UnmarshalJSON(src []byte) error { var value {{^format}}{{dataType}}{{/format}}{{#format}}{{{format}}}{{/format}} err := json.Unmarshal(src, &value) @@ -19,7 +27,7 @@ func (v *{{{classname}}}) UnmarshalJSON(src []byte) error { return err } enumTypeValue := {{{classname}}}(value) - for _, existing := range []{{classname}}{ {{#allowableValues}}{{#enumVars}}{{{value}}}, {{/enumVars}} {{/allowableValues}} } { + for _, existing := range allowed{{{classname}}}EnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -29,6 +37,27 @@ func (v *{{{classname}}}) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid {{classname}}", value) } +// New{{{classname}}}FromValue returns a pointer to a valid {{{classname}}} +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func New{{{classname}}}FromValue(v {{^format}}{{dataType}}{{/format}}{{#format}}{{{format}}}{{/format}}) (*{{{classname}}}, error) { + ev := {{{classname}}}(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for {{{classname}}}: valid values are %v", v, allowed{{{classname}}}EnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v {{{classname}}}) IsValid() bool { + for _, existing := range allowed{{{classname}}}EnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to {{{name}}} value func (v {{{classname}}}) Ptr() *{{{classname}}} { return &v diff --git a/samples/client/petstore/go/go-petstore/model_enum_class.go b/samples/client/petstore/go/go-petstore/model_enum_class.go index 982340ec9c6b..512004b7904b 100644 --- a/samples/client/petstore/go/go-petstore/model_enum_class.go +++ b/samples/client/petstore/go/go-petstore/model_enum_class.go @@ -25,6 +25,12 @@ const ( XYZ EnumClass = "(xyz)" ) +var allowedEnumClassEnumValues = []EnumClass{ + "_abc", + "-efg", + "(xyz)", +} + func (v *EnumClass) UnmarshalJSON(src []byte) error { var value string err := json.Unmarshal(src, &value) @@ -32,7 +38,7 @@ func (v *EnumClass) UnmarshalJSON(src []byte) error { return err } enumTypeValue := EnumClass(value) - for _, existing := range []EnumClass{ "_abc", "-efg", "(xyz)", } { + for _, existing := range allowedEnumClassEnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -42,6 +48,27 @@ func (v *EnumClass) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid EnumClass", value) } +// NewEnumClassFromValue returns a pointer to a valid EnumClass +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func NewEnumClassFromValue(v string) (*EnumClass, error) { + ev := EnumClass(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for EnumClass: valid values are %v", v, allowedEnumClassEnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v EnumClass) IsValid() bool { + for _, existing := range allowedEnumClassEnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to EnumClass value func (v EnumClass) Ptr() *EnumClass { return &v diff --git a/samples/client/petstore/go/go-petstore/model_outer_enum.go b/samples/client/petstore/go/go-petstore/model_outer_enum.go index cc935fc6d86e..a381d0e7615c 100644 --- a/samples/client/petstore/go/go-petstore/model_outer_enum.go +++ b/samples/client/petstore/go/go-petstore/model_outer_enum.go @@ -25,6 +25,12 @@ const ( DELIVERED OuterEnum = "delivered" ) +var allowedOuterEnumEnumValues = []OuterEnum{ + "placed", + "approved", + "delivered", +} + func (v *OuterEnum) UnmarshalJSON(src []byte) error { var value string err := json.Unmarshal(src, &value) @@ -32,7 +38,7 @@ func (v *OuterEnum) UnmarshalJSON(src []byte) error { return err } enumTypeValue := OuterEnum(value) - for _, existing := range []OuterEnum{ "placed", "approved", "delivered", } { + for _, existing := range allowedOuterEnumEnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -42,6 +48,27 @@ func (v *OuterEnum) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid OuterEnum", value) } +// NewOuterEnumFromValue returns a pointer to a valid OuterEnum +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func NewOuterEnumFromValue(v string) (*OuterEnum, error) { + ev := OuterEnum(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for OuterEnum: valid values are %v", v, allowedOuterEnumEnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v OuterEnum) IsValid() bool { + for _, existing := range allowedOuterEnumEnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to OuterEnum value func (v OuterEnum) Ptr() *OuterEnum { return &v diff --git a/samples/openapi3/client/petstore/go/go-petstore/model_enum_class.go b/samples/openapi3/client/petstore/go/go-petstore/model_enum_class.go index 1256c2ce5b67..9bbc1275cde8 100644 --- a/samples/openapi3/client/petstore/go/go-petstore/model_enum_class.go +++ b/samples/openapi3/client/petstore/go/go-petstore/model_enum_class.go @@ -25,6 +25,12 @@ const ( ENUMCLASS_XYZ EnumClass = "(xyz)" ) +var allowedEnumClassEnumValues = []EnumClass{ + "_abc", + "-efg", + "(xyz)", +} + func (v *EnumClass) UnmarshalJSON(src []byte) error { var value string err := json.Unmarshal(src, &value) @@ -32,7 +38,7 @@ func (v *EnumClass) UnmarshalJSON(src []byte) error { return err } enumTypeValue := EnumClass(value) - for _, existing := range []EnumClass{ "_abc", "-efg", "(xyz)", } { + for _, existing := range allowedEnumClassEnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -42,6 +48,27 @@ func (v *EnumClass) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid EnumClass", value) } +// NewEnumClassFromValue returns a pointer to a valid EnumClass +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func NewEnumClassFromValue(v string) (*EnumClass, error) { + ev := EnumClass(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for EnumClass: valid values are %v", v, allowedEnumClassEnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v EnumClass) IsValid() bool { + for _, existing := range allowedEnumClassEnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to EnumClass value func (v EnumClass) Ptr() *EnumClass { return &v diff --git a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum.go b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum.go index 913409fcea66..8779e003e6b0 100644 --- a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum.go +++ b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum.go @@ -25,6 +25,12 @@ const ( OUTERENUM_DELIVERED OuterEnum = "delivered" ) +var allowedOuterEnumEnumValues = []OuterEnum{ + "placed", + "approved", + "delivered", +} + func (v *OuterEnum) UnmarshalJSON(src []byte) error { var value string err := json.Unmarshal(src, &value) @@ -32,7 +38,7 @@ func (v *OuterEnum) UnmarshalJSON(src []byte) error { return err } enumTypeValue := OuterEnum(value) - for _, existing := range []OuterEnum{ "placed", "approved", "delivered", } { + for _, existing := range allowedOuterEnumEnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -42,6 +48,27 @@ func (v *OuterEnum) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid OuterEnum", value) } +// NewOuterEnumFromValue returns a pointer to a valid OuterEnum +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func NewOuterEnumFromValue(v string) (*OuterEnum, error) { + ev := OuterEnum(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for OuterEnum: valid values are %v", v, allowedOuterEnumEnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v OuterEnum) IsValid() bool { + for _, existing := range allowedOuterEnumEnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to OuterEnum value func (v OuterEnum) Ptr() *OuterEnum { return &v diff --git a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_default_value.go b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_default_value.go index a0171022e156..b0c116b7fe0e 100644 --- a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_default_value.go +++ b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_default_value.go @@ -25,6 +25,12 @@ const ( OUTERENUMDEFAULTVALUE_DELIVERED OuterEnumDefaultValue = "delivered" ) +var allowedOuterEnumDefaultValueEnumValues = []OuterEnumDefaultValue{ + "placed", + "approved", + "delivered", +} + func (v *OuterEnumDefaultValue) UnmarshalJSON(src []byte) error { var value string err := json.Unmarshal(src, &value) @@ -32,7 +38,7 @@ func (v *OuterEnumDefaultValue) UnmarshalJSON(src []byte) error { return err } enumTypeValue := OuterEnumDefaultValue(value) - for _, existing := range []OuterEnumDefaultValue{ "placed", "approved", "delivered", } { + for _, existing := range allowedOuterEnumDefaultValueEnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -42,6 +48,27 @@ func (v *OuterEnumDefaultValue) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid OuterEnumDefaultValue", value) } +// NewOuterEnumDefaultValueFromValue returns a pointer to a valid OuterEnumDefaultValue +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func NewOuterEnumDefaultValueFromValue(v string) (*OuterEnumDefaultValue, error) { + ev := OuterEnumDefaultValue(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for OuterEnumDefaultValue: valid values are %v", v, allowedOuterEnumDefaultValueEnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v OuterEnumDefaultValue) IsValid() bool { + for _, existing := range allowedOuterEnumDefaultValueEnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to OuterEnumDefaultValue value func (v OuterEnumDefaultValue) Ptr() *OuterEnumDefaultValue { return &v diff --git a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer.go b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer.go index 777870b5797d..7f5e9dd4588f 100644 --- a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer.go +++ b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer.go @@ -25,6 +25,12 @@ const ( OUTERENUMINTEGER__2 OuterEnumInteger = 2 ) +var allowedOuterEnumIntegerEnumValues = []OuterEnumInteger{ + 0, + 1, + 2, +} + func (v *OuterEnumInteger) UnmarshalJSON(src []byte) error { var value int32 err := json.Unmarshal(src, &value) @@ -32,7 +38,7 @@ func (v *OuterEnumInteger) UnmarshalJSON(src []byte) error { return err } enumTypeValue := OuterEnumInteger(value) - for _, existing := range []OuterEnumInteger{ 0, 1, 2, } { + for _, existing := range allowedOuterEnumIntegerEnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -42,6 +48,27 @@ func (v *OuterEnumInteger) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid OuterEnumInteger", value) } +// NewOuterEnumIntegerFromValue returns a pointer to a valid OuterEnumInteger +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func NewOuterEnumIntegerFromValue(v int32) (*OuterEnumInteger, error) { + ev := OuterEnumInteger(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for OuterEnumInteger: valid values are %v", v, allowedOuterEnumIntegerEnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v OuterEnumInteger) IsValid() bool { + for _, existing := range allowedOuterEnumIntegerEnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to OuterEnumInteger value func (v OuterEnumInteger) Ptr() *OuterEnumInteger { return &v diff --git a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer_default_value.go b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer_default_value.go index b1349ccca041..828b23454f51 100644 --- a/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer_default_value.go +++ b/samples/openapi3/client/petstore/go/go-petstore/model_outer_enum_integer_default_value.go @@ -25,6 +25,12 @@ const ( OUTERENUMINTEGERDEFAULTVALUE__2 OuterEnumIntegerDefaultValue = 2 ) +var allowedOuterEnumIntegerDefaultValueEnumValues = []OuterEnumIntegerDefaultValue{ + 0, + 1, + 2, +} + func (v *OuterEnumIntegerDefaultValue) UnmarshalJSON(src []byte) error { var value int32 err := json.Unmarshal(src, &value) @@ -32,7 +38,7 @@ func (v *OuterEnumIntegerDefaultValue) UnmarshalJSON(src []byte) error { return err } enumTypeValue := OuterEnumIntegerDefaultValue(value) - for _, existing := range []OuterEnumIntegerDefaultValue{ 0, 1, 2, } { + for _, existing := range allowedOuterEnumIntegerDefaultValueEnumValues { if existing == enumTypeValue { *v = enumTypeValue return nil @@ -42,6 +48,27 @@ func (v *OuterEnumIntegerDefaultValue) UnmarshalJSON(src []byte) error { return fmt.Errorf("%+v is not a valid OuterEnumIntegerDefaultValue", value) } +// NewOuterEnumIntegerDefaultValueFromValue returns a pointer to a valid OuterEnumIntegerDefaultValue +// for the value passed as argument, or an error if the value passed is not allowed by the enum +func NewOuterEnumIntegerDefaultValueFromValue(v int32) (*OuterEnumIntegerDefaultValue, error) { + ev := OuterEnumIntegerDefaultValue(v) + if ev.IsValid() { + return &ev, nil + } else { + return nil, fmt.Errorf("invalid value '%v' for OuterEnumIntegerDefaultValue: valid values are %v", v, allowedOuterEnumIntegerDefaultValueEnumValues) + } +} + +// IsValid return true if the value is valid for the enum, false otherwise +func (v OuterEnumIntegerDefaultValue) IsValid() bool { + for _, existing := range allowedOuterEnumIntegerDefaultValueEnumValues { + if existing == v { + return true + } + } + return false +} + // Ptr returns reference to OuterEnumIntegerDefaultValue value func (v OuterEnumIntegerDefaultValue) Ptr() *OuterEnumIntegerDefaultValue { return &v