diff --git a/Makefile b/Makefile index 75ad832..dd8ad66 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ ROOT_DIR ?= $(shell git rev-parse --show-toplevel) SCRIPTS_BASE ?= $(ROOT_DIR)/scripts -API_VERSION ?= $(shell cat api_version|grep -v '^\#'|head -n 1) +API_VERSIONS ?= $(ROOT_DIR)/api-versions-lock.json SDK_BRANCH ?= main # SETUP AND TOOL INITIALIZATION TASKS @@ -12,7 +12,7 @@ project-tools: # GENERATE download-oas: - @$(SCRIPTS_BASE)/download-oas.sh "$(OAS_REPO_NAME)" "$(OAS_REPO)" "$(ALLOW_ALPHA)" "$(API_VERSION)" + @$(SCRIPTS_BASE)/download-oas.sh "$(OAS_REPO_NAME)" "$(OAS_REPO)" "$(ALLOW_ALPHA)" "$(API_VERSIONS)" generate-sdk: @$(SCRIPTS_BASE)/generate-sdk/generate-sdk.sh "$(GIT_HOST)" "$(GIT_USER_ID)" "$(GIT_REPO_ID)" "$(SDK_REPO_URL)" "$(LANGUAGE)" "$(SDK_BRANCH)" diff --git a/api-versions-lock.json b/api-versions-lock.json new file mode 100644 index 0000000..083d47a --- /dev/null +++ b/api-versions-lock.json @@ -0,0 +1,4 @@ +{ + "load-balancer": "9c9de238a3e650f4bed9b9d9ade151da9a97e1d6", + "certificates": "c592757243833f9b506a7d23ec5a80a9b3c984ae" +} \ No newline at end of file diff --git a/api_version b/api_version deleted file mode 100644 index 76fd610..0000000 --- a/api_version +++ /dev/null @@ -1,3 +0,0 @@ -# 2e3768b7b65237391fc587eddd559451f2b183a6 -# comments are allowed! -main \ No newline at end of file diff --git a/blacklist.txt b/blacklist.txt index 279694c..a3065e5 100644 --- a/blacklist.txt +++ b/blacklist.txt @@ -1,2 +1 @@ -# Transitional file to disable generation for selected services -cdn \ No newline at end of file +# Transitional file to disable generation for selected services \ No newline at end of file diff --git a/scripts/download-oas.sh b/scripts/download-oas.sh index 8336a1f..d0a8b7c 100755 --- a/scripts/download-oas.sh +++ b/scripts/download-oas.sh @@ -6,7 +6,7 @@ ROOT_DIR=$(git rev-parse --show-toplevel) OAS_REPO_NAME=$1 OAS_REPO=$2 ALLOW_ALPHA=$3 -OAS_API_VERSION=$4 +OAS_API_VERSIONS=$4 if [[ -z ${OAS_REPO_NAME} ]]; then echo "Repo name is empty, default public OAS repo name will be used." @@ -18,9 +18,9 @@ if [[ ! ${OAS_REPO} || -d ${OAS_REPO} ]]; then OAS_REPO="https://github.com/stackitcloud/${OAS_REPO_NAME}.git" fi -if [[ -z ${OAS_API_VERSION} ]]; then - echo "No API version passed, main branch will be used" - OAS_API_VERSION="main" +if [[ -z ${OAS_API_VERSIONS} ]]; then + echo "No API version passed, using ${ROOTDIR}/api-versions-lock.json" + OAS_API_VERSIONS="${ROOT_DIR}/api-versions-lock.json" fi # Create temp directory to clone OAS repo @@ -41,16 +41,23 @@ mkdir ${ROOT_DIR}/oas cd ${work_dir} git clone ${OAS_REPO} --quiet -echo "Using api version ${OAS_API_VERSION}" -cd ${OAS_REPO_NAME} -git checkout --quiet ${OAS_API_VERSION} -cd - - for service_dir in ${work_dir}/${OAS_REPO_NAME}/services/*; do + max_version_dir="" max_version=-1 service=$(basename "$service_dir") + apiVersion=$(jq -r -f <(cat < /dev/null + git checkout -q $apiVersion || (echo "version ${apiVersion} does not exist, using main instead" && git checkout -q main) + cd - > /dev/null + # Prioritize GA over Beta over Alpha versions # GA priority = 3, Beta priority = 2, Alpha priority = 1 max_version_priority=1 diff --git a/templates/go/api.mustache b/templates/go/api.mustache index 4b3f6a4..3ce8436 100644 --- a/templates/go/api.mustache +++ b/templates/go/api.mustache @@ -8,8 +8,8 @@ import ( "io" "net/http" "net/url" - "{{gitHost}}/{{gitUserId}}/{{gitRepoId}}/core/config" - "{{gitHost}}/{{gitUserId}}/{{gitRepoId}}/core/oapierror" + "github.com/stackitcloud/stackit-sdk-go/core/config" + "github.com/stackitcloud/stackit-sdk-go/core/oapierror" {{#imports}} "{{import}}" {{/imports}} ) diff --git a/templates/go/api_test.mustache b/templates/go/api_test.mustache index 317d1cb..cd38b64 100644 --- a/templates/go/api_test.mustache +++ b/templates/go/api_test.mustache @@ -19,7 +19,7 @@ import ( "net/url" "strings" "testing" - "{{gitHost}}/{{gitUserId}}/{{gitRepoId}}/core/config" + "github.com/stackitcloud/stackit-sdk-go/core/config" ) func Test_{{packageName}}_{{classname}}Service(t *testing.T) { @@ -27,12 +27,12 @@ func Test_{{packageName}}_{{classname}}Service(t *testing.T) { {{#operations}} {{#operation}} t.Run("Test {{classname}}Service {{{nickname}}}", func(t *testing.T) { - path := "{{{path}}}"{{#pathParams}} - {{paramName}}Value := {{#isString}}"{{paramName}}"{{/isString}}{{#isNumber}}123{{/isNumber}}{{#isFloat}}float32(123){{/isFloat}}{{#isDouble}}float64(123){{/isDouble}}{{#isInteger}}int32(123){{/isInteger}}{{#isLong}}int64(123){{/isLong}}{{^isString}}{{^isInteger}}{{defaultValue}}{{/isInteger}}{{/isString}} - path = strings.Replace(path, "{"+"{{baseName}}"+"}", url.PathEscape(ParameterValueToString({{paramName}}Value, "{{paramName}}")), -1){{/pathParams}} + _apiUrlPath := "{{{path}}}"{{#pathParams}} + {{paramName}}Value := {{#isAnyType}}"unspecified type"{{/isAnyType}}{{#isString}}{{#isUuid}}uuid.NewString(){{/isUuid}}{{^isUuid}}"{{paramName}}"{{/isUuid}}{{/isString}}{{#isNumber}}123{{/isNumber}}{{#isFloat}}float32(123){{/isFloat}}{{#isDouble}}float64(123){{/isDouble}}{{#isInteger}}int32(123){{/isInteger}}{{#isLong}}int64(123){{/isLong}}{{^isString}}{{^isInteger}}{{defaultValue}}{{/isInteger}}{{/isString}} + _apiUrlPath = strings.Replace(_apiUrlPath, "{"+"{{baseName}}"+"}", url.PathEscape(ParameterValueToString({{paramName}}Value, "{{paramName}}")), -1){{/pathParams}} test{{classname}}ServeMux := http.NewServeMux() - test{{classname}}ServeMux.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) { + test{{classname}}ServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) { {{! Only binary data sets a ReturnFormat}} {{#returnFormat}} w.Header().Add("Content-Type", "application/octet-stream") @@ -41,7 +41,18 @@ func Test_{{packageName}}_{{classname}}Service(t *testing.T) { {{/returnFormat}} {{^returnFormat}} {{#returnType}} + {{#returnProperty.isPrimitiveType}} + {{! according to the model, freeform objects might be primitive...}} + {{#returnProperty.isFreeFormObject}} data := {{{.}}}{} + {{/returnProperty.isFreeFormObject}} + {{^returnProperty.isFreeFormObject}} + var data {{{.}}} + {{/returnProperty.isFreeFormObject}} + {{/returnProperty.isPrimitiveType}} + {{^returnProperty.isPrimitiveType}} + data := {{{.}}}{} + {{/returnProperty.isPrimitiveType}} w.Header().Add("Content-Type", "application/json") json.NewEncoder(w).Encode(data) {{/returnType}} @@ -79,7 +90,7 @@ func Test_{{packageName}}_{{classname}}Service(t *testing.T) { {{#allParams}} {{#required}} {{#isPathParam}} - {{paramName}} := {{#isString}}"{{paramName}}"{{/isString}}{{#isNumber}}123{{/isNumber}}{{#isFloat}}float32(123){{/isFloat}}{{#isDouble}}float64(123){{/isDouble}}{{#isInteger}}int32(123){{/isInteger}}{{#isLong}}int64(123){{/isLong}}{{^isString}}{{^isInteger}}{{defaultValue}}{{/isInteger}}{{/isString}} + {{paramName}} := {{paramName}}Value {{/isPathParam}} {{^isPathParam}} {{#isPrimitiveType}} @@ -98,7 +109,7 @@ func Test_{{packageName}}_{{classname}}Service(t *testing.T) { t.Fatalf("error in call: %v", reqErr) } {{#returnType}} - if resp == nil { + if IsNil(resp) { t.Fatalf("response not present") } {{/returnType}} diff --git a/templates/go/client.mustache b/templates/go/client.mustache index 4aebded..808a1d4 100644 --- a/templates/go/client.mustache +++ b/templates/go/client.mustache @@ -21,8 +21,8 @@ import ( "strings" "time" "unicode/utf8" - "{{gitHost}}/{{gitUserId}}/{{gitRepoId}}/core/config" - "{{gitHost}}/{{gitUserId}}/{{gitRepoId}}/core/auth" + "github.com/stackitcloud/stackit-sdk-go/core/config" + "github.com/stackitcloud/stackit-sdk-go/core/auth" {{#hasOAuthMethods}} "golang.org/x/oauth2" diff --git a/templates/go/configuration.mustache b/templates/go/configuration.mustache index 42adeda..50f1c33 100644 --- a/templates/go/configuration.mustache +++ b/templates/go/configuration.mustache @@ -2,7 +2,7 @@ package {{packageName}} import ( - "{{gitHost}}/{{gitUserId}}/{{gitRepoId}}/core/config" + "github.com/stackitcloud/stackit-sdk-go/core/config" ) // NewConfiguration returns a new Configuration object diff --git a/templates/go/go.mod.mustache b/templates/go/go.mod.mustache index 4bbea27..907801a 100644 --- a/templates/go/go.mod.mustache +++ b/templates/go/go.mod.mustache @@ -3,5 +3,5 @@ module {{gitHost}}/{{gitUserId}}/{{gitRepoId}}/services{{#isGoSubmodule}}/{{pack go 1.21 require ( - {{gitHost}}/{{gitUserId}}/{{gitRepoId}}/core v0.16.0 + github.com/stackitcloud/stackit-sdk-go/core v0.16.0 ) diff --git a/templates/go/model_simple.mustache b/templates/go/model_simple.mustache index 566506c..28709a9 100644 --- a/templates/go/model_simple.mustache +++ b/templates/go/model_simple.mustache @@ -1,6 +1,470 @@ // checks if the {{classname}} type satisfies the MappedNullable interface at compile time var _ MappedNullable = &{{classname}}{} +{{#vars}} + +/* + types and functions for {{baseName}} + {{!.}} +*/ + +{{! The basic approach is as follows: To avoid checking the various datatypes, }} +{{! exceptions and non-orthogonal model states we introduce go type-alias }} +{{! These are compatible with their basic types (this maintains backwards)}} +{{! compatibility with existing code). This allows to concentrate the decision what }} +{{! actual type the openapi represents in a single place. Reusing the generated}} +{{! type in all other places avoids repetion of the non-trivial decision matrix}} +{{! which type is to be used.}} +{{! We define three basic types:}} +{{! - FooAttributeType: The type used for the model-struct definitions, i.e. the struct attribute type}} +{{! - FooArgType: The type used for parameter passing, i.e. in function calls}} +{{! - FooRetType: The type used for function returns.}} +{{! To simplify reading and writing values even further, type-safe}} +{{! helper methods for getting and setting valuesare generated as well}} +{{! (these are not rendered as methods, as the structs themselves may be nil)}} +{{! (a pure function avoids possible nil-pointer exceptions)}} + + +{{! address primitives types, excluding enums (they are handled explicitly below) }} +{{^isEnum}} +{{#isNumber}} +// isNumber +type {{classname}}{{getter}}AttributeType = *float64 +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}float64 +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}float64 +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isNumber}} +{{#isFloat}} +// isFloat +type {{classname}}{{getter}}AttributeType = *float64 +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}float64 +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}float64 +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isFloat}} +{{#isDouble}} +// isDouble +type {{classname}}{{getter}}AttributeType = *float64 +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}float64 +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}float64 +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isDouble}} +{{#isShort}} +{{! isShort and isInteger may be true at the same time, so select one}} +{{^isInteger}} +// isShort +type {{classname}}{{getter}}AttributeType = *int64 +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}int64 +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}int64 +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isInteger}} +{{/isShort}} +{{#isInteger}} +// isInteger +type {{classname}}{{getter}}AttributeType = *int64 +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}int64 +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}int64 +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isInteger}} +{{#isLong}} +// isLong +type {{classname}}{{getter}}AttributeType = *int64 +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}int64 +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}int64 +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isLong}} +{{#isString}} +{{! string-types are definitely used non-orthogonally, so we have to exclude some possibilities}} +{{^isArray}} +{{! skip arrays, they are addressed explicitly below}} +{{#isNullable}} +{{! nullable strings have a special type}} +// isNullableString +type {{classname}}{{getter}}AttributeType = *NullableString +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return arg.Get(),true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + if IsNil(*arg) { + *arg = NewNullableString(val) + } else { + (*arg).Set(val) + } +} +{{/isNullable}} +{{^isNullable}} +{{! non nullable strings are plain string pointers}} +// isNotNullableString +type {{classname}}{{getter}}AttributeType = *string +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isNullable}} +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}string +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}string +{{/isArray}} +{{/isString}} +{{#isAnyType}} +// isAny +type {{classname}}{{getter}}AttributeType = any +type {{classname}}{{getter}}ArgType = any +type {{classname}}{{getter}}RetType = any +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isAnyType}} +{{/isEnum}} + +{{#isDateTime}} +{{! special handling for date-time}} +// isDateTime +type {{classname}}{{getter}}AttributeType = *time.Time +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}time.Time +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}time.Time +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isDateTime}} +{{#isDate}} +{{! special handling for date}} +// isDate +type {{classname}}{{getter}}AttributeType = *time.Time +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}time.Time +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}time.Time +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isDate}} +{{#isEnumRef}} +{{! special handling for enums}} +// isEnumRef +type {{classname}}{{getter}}AttributeType = *{{^isNumeric}}{{dataType}}{{/isNumeric}}{{#isNumeric}}int64{{/isNumeric}} +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}{{^isNumeric}}{{dataType}}{{/isNumeric}}{{#isNumeric}}int64{{/isNumeric}} +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}{{^isNumeric}}{{dataType}}{{/isNumeric}}{{#isNumeric}}int64{{/isNumeric}} +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isEnumRef}} +{{#isModel}} +{{! special handling for recursive datatypes}} +// isModel +type {{classname}}{{getter}}AttributeType = *{{dataType}} +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}{{dataType}} +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}{{dataType}} +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isModel}} +{{^isPrimitiveType}} +{{^isModel}} +{{^isMap}} +{{^isArray}} +{{^isDateTime}} +{{^isEnumRef}} +// fallback +{{! everything else will end up here}} +type {{classname}}{{getter}}AttributeType = *{{dataType}} +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}{{dataType}} +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}{{dataType}} +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isEnumRef}} +{{/isDateTime}} +{{/isArray}} +{{/isMap}} +{{/isModel}} +{{/isPrimitiveType}} +{{#isArray}} +// isArray +type {{classname}}{{getter}}AttributeType = *{{dataType}} +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}{{dataType}} +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}{{dataType}} +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isArray}} + + +{{#isFreeFormObject}} +// isFreeform +type {{classname}}{{getter}}AttributeType = *{{dataType}} +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}{{dataType}} +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}{{dataType}} +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isFreeFormObject}} +{{#isContainer}} +{{^isFreeFormObject}} +{{^isArray}} +// isContainer +type {{classname}}{{getter}}AttributeType = *{{dataType}} +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}{{dataType}} +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}{{dataType}} +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isArray}} +{{/isFreeFormObject}} +{{/isContainer}} +{{#isByteArray}} +// isByteArray +type {{classname}}{{getter}}AttributeType = *[]byte +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}[]byte +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}[]byte +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isByteArray}} +{{#isBoolean}} +// isBoolean +type {{classname}}{{getter}}AttributeType = *bool +type {{classname}}{{getter}}ArgType = {{#isNullable}}*{{/isNullable}}bool +type {{classname}}{{getter}}RetType = {{#isNullable}}*{{/isNullable}}bool +func get{{classname}}{{getter}}AttributeTypeOk(arg {{classname}}{{getter}}AttributeType) (ret {{classname}}{{getter}}RetType, ok bool) { + if arg == nil { + {{#isNullable}} + return nil,false + {{/isNullable}} + {{^isNullable}} + return ret,false + {{/isNullable}} + } + return {{^isNullable}}*{{/isNullable}}arg,true +} + +func set{{classname}}{{getter}}AttributeType(arg *{{classname}}{{getter}}AttributeType, val {{classname}}{{getter}}RetType) { + *arg={{^isNullable}}&{{/isNullable}}val +} +{{/isBoolean}} + +{{/vars}} + // {{classname}} {{{description}}}{{^description}}struct for {{{classname}}}{{/description}} type {{classname}} struct { {{#parent}} @@ -37,11 +501,11 @@ type {{classname}} struct { {{/isWriteOnly}} {{/isReadOnly}} {{/required}} - {{name}} *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{{dataType}}}{{/isNumeric}} `json:"{{baseName}}{{#required}}{{#isReadOnly}},omitempty{{/isReadOnly}}{{/required}}{{#required}}{{#isWriteOnly}},omitempty{{/isWriteOnly}}{{/required}}{{^required}},omitempty{{/required}}"{{#withXml}} xml:"{{baseName}}{{#isXmlAttribute}},attr{{/isXmlAttribute}}"{{/withXml}}{{#vendorExtensions.x-go-custom-tag}} {{{.}}}{{/vendorExtensions.x-go-custom-tag}}` + {{name}} {{classname}}{{getter}}AttributeType `json:"{{baseName}}{{#required}}{{#isReadOnly}},omitempty{{/isReadOnly}}{{/required}}{{#required}}{{#isWriteOnly}},omitempty{{/isWriteOnly}}{{/required}}{{^required}},omitempty{{/required}}"{{#withXml}} xml:"{{baseName}}{{#isXmlAttribute}},attr{{/isXmlAttribute}}"{{/withXml}}{{#vendorExtensions.x-go-custom-tag}} {{{.}}}{{/vendorExtensions.x-go-custom-tag}}` +{{/vars}} {{#isAdditionalPropertiesTrue}} AdditionalProperties map[string]interface{} {{/isAdditionalPropertiesTrue}} -{{/vars}} } @@ -59,27 +523,11 @@ type _{{{classname}}} {{{classname}}} // This constructor will assign default values to properties that have it defined, // and makes sure properties required by API are set, but the set of arguments // will change when the set of required properties is changed -func New{{classname}}({{#requiredVars}}{{nameInCamelCase}} *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{{dataType}}}{{/isNumeric}}{{^-last}}, {{/-last}}{{/requiredVars}}) *{{classname}} { +func New{{classname}}({{#requiredVars}}{{nameInCamelCase}} {{classname}}{{getter}}ArgType{{^-last}}, {{/-last}}{{/requiredVars}}) *{{classname}} { this := {{classname}}{} {{#allVars}} {{#required}} - this.{{name}} = {{nameInCamelCase}} -{{/required}} -{{^required}} -{{#defaultValue}} -{{^vendorExtensions.x-golang-is-container}} -{{^isReadOnly}} -{{#isNullable}} - var {{nameInCamelCase}} {{{datatypeWithEnum}}} = {{{.}}} - this.{{name}} = *New{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{{dataType}}}{{/isNumeric}}(&{{nameInCamelCase}}) -{{/isNullable}} -{{^isNullable}} - var {{nameInCamelCase}} {{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{{dataType}}}{{/isNumeric}} = {{{.}}} - this.{{name}} = &{{nameInCamelCase}} -{{/isNullable}} -{{/isReadOnly}} -{{/vendorExtensions.x-golang-is-container}} -{{/defaultValue}} + set{{classname}}{{getter}}AttributeType(&this.{{name}}, {{nameInCamelCase}}) {{/required}} {{/allVars}} return &this @@ -94,13 +542,12 @@ func New{{classname}}WithDefaults() *{{classname}} { {{#defaultValue}} {{^vendorExtensions.x-golang-is-container}} {{^isReadOnly}} -{{#isNullable}} {{!we use datatypeWithEnum here, since it will represent the non-nullable name of the datatype, e.g. int64 for NullableInt64}} - var {{nameInCamelCase}} {{{datatypeWithEnum}}} = {{{.}}} - this.{{name}} = *New{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{{dataType}}}{{/isNumeric}}(&{{nameInCamelCase}}) + var {{nameInCamelCase}} {{#isInteger}}int64{{/isInteger}}{{#isNumber}}float64{{/isNumber}}{{^isNumber}}{{^isInteger}}{{dataType}}{{/isInteger}}{{/isNumber}} = {{{.}}} +{{#isNullable}} + this.{{name}} = *New{{dataType}}(&{{nameInCamelCase}}) {{/isNullable}} {{^isNullable}} - var {{nameInCamelCase}} {{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{{dataType}}}{{/isNumeric}} = {{{.}}} this.{{name}} = &{{nameInCamelCase}} {{/isNullable}} {{/isReadOnly}} @@ -119,23 +566,9 @@ func New{{classname}}WithDefaults() *{{classname}} { {{#deprecated}} // Deprecated {{/deprecated}} -func (o *{{classname}}) Get{{name}}() *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}} { - if o == nil|| IsNil(o.{{name}}) {{#isNullable}}{{^vendorExtensions.x-golang-is-container}} || o.{{name}}.Get() == nil{{/vendorExtensions.x-golang-is-container}}{{/isNullable}} { - var ret *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}} - return ret - } - -{{#isNullable}} -{{#vendorExtensions.x-golang-is-container}} - return o.{{name}} -{{/vendorExtensions.x-golang-is-container}} -{{^vendorExtensions.x-golang-is-container}} - return o.{{name}}.Get() -{{/vendorExtensions.x-golang-is-container}} -{{/isNullable}} -{{^isNullable}} - return o.{{name}} -{{/isNullable}} +func (o *{{classname}}) Get{{name}}() (ret {{classname}}{{getter}}RetType) { + ret,_ = o.Get{{name}}Ok() + return ret } // Get{{name}}Ok returns a tuple with the {{name}} field value @@ -146,47 +579,16 @@ func (o *{{classname}}) Get{{name}}() *{{#isNumber}}float64{{/isNumber}}{{#isFlo {{#deprecated}} // Deprecated {{/deprecated}} -func (o *{{classname}}) Get{{name}}Ok() (*{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}}, bool) { - if o == nil{{#isNullable}}{{#vendorExtensions.x-golang-is-container}} || IsNil(o.{{name}}){{/vendorExtensions.x-golang-is-container}}{{/isNullable}} { -{{^isFreeFormObject}} - return nil, false - {{/isFreeFormObject}} - {{#isFreeFormObject}} - return &{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}}{}, false - {{/isFreeFormObject}} - } -{{#isNullable}} -{{#vendorExtensions.x-golang-is-container}} - return {{^isArray}}{{^isFreeFormObject}}&{{/isFreeFormObject}}{{/isArray}}o.{{name}}, true -{{/vendorExtensions.x-golang-is-container}} -{{^vendorExtensions.x-golang-is-container}} - return o.{{name}}.Get(), o.{{name}}.IsSet() -{{/vendorExtensions.x-golang-is-container}} -{{/isNullable}} -{{^isNullable}} - return o.{{name}}, true -{{/isNullable}} +func (o *{{classname}}) Get{{name}}Ok() (ret {{classname}}{{getter}}RetType, ok bool) { + return get{{classname}}{{getter}}AttributeTypeOk(o.{{name}}) } // Set{{name}} sets field value {{#deprecated}} // Deprecated {{/deprecated}} -func (o *{{classname}}) Set{{name}}(v *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}}) { -{{#isNullable}} -{{#vendorExtensions.x-golang-is-container}} - o.{{name}} = v -{{/vendorExtensions.x-golang-is-container}} -{{^vendorExtensions.x-golang-is-container}} - if IsNil(o.{{name}}) { - o.{{name}} = new({{dataType}}) - } - o.{{name}}.Set(v) -{{/vendorExtensions.x-golang-is-container}} -{{/isNullable}} -{{^isNullable}} - o.{{name}} = v -{{/isNullable}} +func (o *{{classname}}) Set{{name}}(v {{classname}}{{getter}}RetType) { + set{{classname}}{{getter}}AttributeType(&o.{{name}},v) } {{/required}} @@ -195,22 +597,9 @@ func (o *{{classname}}) Set{{name}}(v *{{#isNumber}}float64{{/isNumber}}{{#isFlo {{#deprecated}} // Deprecated {{/deprecated}} -func (o *{{classname}}) Get{{name}}() *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}} { - if o == nil || IsNil(o.{{name}}) {{#isNullable}}{{^vendorExtensions.x-golang-is-container}} || IsNil(o.{{name}}.Get()){{/vendorExtensions.x-golang-is-container}}{{/isNullable}} { - var ret *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}} - return ret - } -{{#isNullable}} -{{#vendorExtensions.x-golang-is-container}} - return o.{{name}} -{{/vendorExtensions.x-golang-is-container}} -{{^vendorExtensions.x-golang-is-container}} - return o.{{name}}.Get() -{{/vendorExtensions.x-golang-is-container}} -{{/isNullable}} -{{^isNullable}} - return o.{{name}} -{{/isNullable}} +func (o *{{classname}}) Get{{name}}() (res {{classname}}{{getter}}RetType) { + res,_ = o.Get{{name}}Ok() + return } // Get{{name}}Ok returns a tuple with the {{name}} field value if set, nil otherwise @@ -221,73 +610,35 @@ func (o *{{classname}}) Get{{name}}() *{{#isNumber}}float64{{/isNumber}}{{#isFlo {{#deprecated}} // Deprecated {{/deprecated}} -func (o *{{classname}}) Get{{name}}Ok() (*{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}}, bool) { - if o == nil || IsNil(o.{{name}}) { - {{^isFreeFormObject}} - return nil, false - {{/isFreeFormObject}} - {{#isFreeFormObject}} - return &{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}}{}, false - {{/isFreeFormObject}} - } -{{#isNullable}} -{{#vendorExtensions.x-golang-is-container}} - return {{^isArray}}{{^isFreeFormObject}}{{^isAnyType}}&{{/isAnyType}}{{/isFreeFormObject}}{{/isArray}}o.{{name}}, true -{{/vendorExtensions.x-golang-is-container}} -{{^vendorExtensions.x-golang-is-container}} - return o.{{name}}.Get(), o.{{name}}.IsSet() -{{/vendorExtensions.x-golang-is-container}} -{{/isNullable}} -{{^isNullable}} - return o.{{name}}, true -{{/isNullable}} +func (o *{{classname}}) Get{{name}}Ok() (ret {{classname}}{{getter}}RetType, ok bool) { + return get{{classname}}{{getter}}AttributeTypeOk(o.{{name}}) } // Has{{name}} returns a boolean if a field has been set. func (o *{{classname}}) Has{{name}}() bool { - if o != nil && !IsNil(o.{{name}}){{#isNullable}}{{^vendorExtensions.x-golang-is-container}} && o.{{name}}.IsSet(){{/vendorExtensions.x-golang-is-container}}{{/isNullable}} { - return true - } - - return false + _,ok:=o.Get{{name}}Ok() + return ok } // Set{{name}} gets a reference to the given {{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}} and assigns it to the {{name}} field. {{#deprecated}} // Deprecated {{/deprecated}} -func (o *{{classname}}) Set{{name}}(v *{{#isNumber}}float64{{/isNumber}}{{#isFloat}}float64{{/isFloat}}{{#isDouble}}float64{{/isDouble}}{{#isInteger}}int64{{/isInteger}}{{#isLong}}int64{{/isLong}}{{^isNumeric}}{{vendorExtensions.x-go-base-type}}{{/isNumeric}}) { -{{#isNullable}} -{{#vendorExtensions.x-golang-is-container}} - o.{{name}} = v -{{/vendorExtensions.x-golang-is-container}} -{{^vendorExtensions.x-golang-is-container}} - if IsNil(o.{{name}}) { - o.{{name}} = new({{dataType}}) - } - o.{{name}}.Set(v) -{{/vendorExtensions.x-golang-is-container}} -{{/isNullable}} -{{^isNullable}} - o.{{name}} = v -{{/isNullable}} +func (o *{{classname}}) Set{{name}}(v {{classname}}{{getter}}RetType) { + set{{classname}}{{getter}}AttributeType(&o.{{name}},v) } + + {{#isNullable}} {{^vendorExtensions.x-golang-is-container}} // Set{{name}}Nil sets the value for {{name}} to be an explicit nil func (o *{{classname}}) Set{{name}}Nil() { - if IsNil(o.{{name}}) { - o.{{name}} = new({{dataType}}) - } - o.{{name}}.Set(nil) + o.{{name}} = nil } // Unset{{name}} ensures that no value is present for {{name}}, not even an explicit nil func (o *{{classname}}) Unset{{name}}() { - if IsNil(o.{{name}}) { - o.{{name}} = new({{dataType}}) - } - o.{{name}}.Unset() + o.{{name}} = nil } {{/vendorExtensions.x-golang-is-container}} {{/isNullable}} @@ -327,35 +678,10 @@ func (o {{classname}}) ToMap() (map[string]interface{}, error) { {{/parent}} {{#vars}} {{! if argument is nullable, only serialize it if it is set}} - {{#isNullable}} - {{#vendorExtensions.x-golang-is-container}} - {{! support for container fields is not ideal at this point because of lack of Nullable* types}} - if o.{{name}} != nil { - toSerialize["{{{baseName}}}"] = o.{{name}} - } - {{/vendorExtensions.x-golang-is-container}} - {{^vendorExtensions.x-golang-is-container}} - {{#required}} - toSerialize["{{{baseName}}}"] = o.{{name}}.Get() - {{/required}} - {{^required}} - if o.{{name}}.IsSet() { - toSerialize["{{{baseName}}}"] = o.{{name}}.Get() - } - {{/required}} - {{/vendorExtensions.x-golang-is-container}} - {{/isNullable}} {{! if argument is not nullable, don't set it if it is nil}} - {{^isNullable}} - {{#required}} - toSerialize["{{{baseName}}}"] = o.{{name}} - {{/required}} - {{^required}} - if !IsNil(o.{{name}}) { - toSerialize["{{{baseName}}}"] = o.{{name}} - } - {{/required}} - {{/isNullable}} + if val,ok:=get{{classname}}{{getter}}AttributeTypeOk(o.{{name}});ok { + toSerialize["{{{name}}}"] = val + } {{/vars}} {{#isAdditionalPropertiesTrue}} @@ -382,7 +708,7 @@ func (o *{{{classname}}}) UnmarshalJSON(data []byte) (err error) { // that every required field exists as a key in the generic map. requiredProperties := []string{ {{#requiredVars}} - "{{baseName}}", + "{{nameInCamelCase}}", {{/requiredVars}} } diff --git a/templates/go/utils.mustache b/templates/go/utils.mustache index 8ba1109..4bd0284 100644 --- a/templates/go/utils.mustache +++ b/templates/go/utils.mustache @@ -31,6 +31,29 @@ func PtrString(v string) *string { return &v } // PtrTime is helper routine that returns a pointer to given Time value. func PtrTime(v time.Time) *time.Time { return &v } +type NullableValue[T any] struct { + value *T + isSet bool +} + +func (v NullableValue[T]) Get() *T { + return v.value +} + +func (v *NullableValue[T]) Set(val *T) { + v.value = val + v.isSet = true +} + +func (v NullableValue[T]) IsSet() bool { + return v.isSet +} + +func (v *NullableValue[T]) Unset() { + v.value = nil + v.isSet = false +} + type NullableBool struct { value *bool isSet bool @@ -324,6 +347,9 @@ func IsNil(i interface{}) bool { if i == nil { return true } + if t,ok:=i.(interface{ IsSet() bool});ok { + return !t.IsSet() + } switch reflect.TypeOf(i).Kind() { case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.UnsafePointer, reflect.Interface, reflect.Slice: return reflect.ValueOf(i).IsNil()