diff --git a/.circleci/config.yml b/.circleci/config.yml deleted file mode 100644 index fd77bd39..00000000 --- a/.circleci/config.yml +++ /dev/null @@ -1,47 +0,0 @@ -version: 2 - - -common_parts: &common_parts - steps: - - checkout - - run: - name: Build - command: | - make build - - run: - name: Test - command: | - make cover - if [[ -n "$COVERALLS_TOKEN" ]]; then - make coveralls - fi - - store_artifacts: - path: coverage.html - - -jobs: - golang_1.12: - docker: - - image: circleci/golang:1.12 - <<: *common_parts - golang_1.13: - docker: - - image: circleci/golang:1.13 - <<: *common_parts - golang_1.14: - docker: - - image: circleci/golang:1.14 - <<: *common_parts - golang_1.15: - docker: - - image: circleci/golang:1.15 - <<: *common_parts - -workflows: - version: 2 - build_and_test: - jobs: - - golang_1.12 - - golang_1.13 - - golang_1.14 - - golang_1.15 diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 00000000..9f0289b1 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,24 @@ +version: 2 +updates: + - package-ecosystem: gomod + directory: / + schedule: + interval: weekly + groups: + major: + update-types: + - major + minor: + update-types: + - minor + - patch + - package-ecosystem: github-actions + directory: "/" + schedule: + interval: weekly + groups: + actions: + update-types: + - major + - minor + - patch diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml new file mode 100644 index 00000000..99a4776e --- /dev/null +++ b/.github/workflows/build_and_test.yml @@ -0,0 +1,54 @@ +name: build and test + +on: + push: + branches: + - master + pull_request: + +jobs: + build: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + go: + - "1.20" + - "1.21" + name: run tests with go version ${{ matrix.go }} + steps: + - name: install go + uses: actions/setup-go@v5 + with: + go-version: ${{ matrix.go }} + + - name: checkout code + uses: actions/checkout@v4 + + - name: Build + run: make build + + - name: Test + env: + COVERALLS_TOKEN: ${{ secrets.COVERALLS_TOKEN }} + run: | + make cover + + - name: Coveralls + if: (matrix.go == '1.21') + env: + COVERALLS_TOKEN: ${{ secrets.COVERALLS_TOKEN }} + run: | + if [[ -n "$COVERALLS_TOKEN" ]]; then + make coveralls + fi + + - name: Upload coverage + if: (matrix.go == '1.21') + uses: actions/upload-artifact@v4 + with: + name: coverage + path: coverage.* + + - name: Assert no changes + run: make assert-no-changes diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..3dfc6b15 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,46 @@ +name: goreleaser + +on: + release: + types: + - "created" + +jobs: + goreleaser: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: ">=1.20.2" + - name: Ensure Go + run: go version + + - name: Install GoReleaser + uses: goreleaser/goreleaser-action@v5 + with: + install-only: true + - name: Show GoReleaser version + run: goreleaser -v + + - name: Login to Docker Hub + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Run GoReleaser + uses: goreleaser/goreleaser-action@v5 + if: success() && startsWith(github.ref, 'refs/tags/') + with: + # either 'goreleaser' (default) or 'goreleaser-pro' + distribution: goreleaser + version: latest + args: release --clean + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/release_check.yml b/.github/workflows/release_check.yml new file mode 100644 index 00000000..498e0dab --- /dev/null +++ b/.github/workflows/release_check.yml @@ -0,0 +1,35 @@ +name: goreleaser + +on: + push: {} + +jobs: + goreleaser: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: ">=1.20.2" + - name: Ensure Go + run: go version + + - name: Install GoReleaser + uses: goreleaser/goreleaser-action@v5 + with: + install-only: true + - name: Show GoReleaser version + run: goreleaser -v + + - name: Run GoReleaser + uses: goreleaser/goreleaser-action@v5 + with: + # either 'goreleaser' (default) or 'goreleaser-pro' + distribution: goreleaser + version: latest + args: release --clean --snapshot diff --git a/.gitignore b/.gitignore index 6fb76ba6..70019a2a 100644 --- a/.gitignore +++ b/.gitignore @@ -18,3 +18,6 @@ vendor/ coverage.out coverage.html + +dist/ +.idea/ \ No newline at end of file diff --git a/.goreleaser.yml b/.goreleaser.yml new file mode 100644 index 00000000..52ec91c0 --- /dev/null +++ b/.goreleaser.yml @@ -0,0 +1,41 @@ +builds: + - env: + - CGO_ENABLED=0 + goos: + - linux + - windows + - darwin + +checksum: + name_template: "{{ .ProjectName }}_checksums.txt" + +archives: + # Distribute just the binaries by default + - format: binary + name_template: >- + {{ .ProjectName }}_ + {{- title .Os }}_ + {{- if eq .Arch "amd64" }}x86_64 + {{- else if eq .Arch "386" }}i386 + {{- else }}{{ .Arch }}{{ end }} + +kos: + - repository: abice/go-enum + base_image: cgr.dev/chainguard/go # need the go binary for formatting 🔧 purposes 🫤 + tags: + - "{{.Version}}" + - latest + bare: true + preserve_import_paths: false + platforms: + - linux/amd64 + - linux/arm64 + +snapshot: + name_template: "{{ incpatch .Version }}-next" +changelog: + sort: asc + filters: + exclude: + - "^docs:" + - "^test:" diff --git a/.ko.yaml b/.ko.yaml new file mode 100644 index 00000000..ffab3c8d --- /dev/null +++ b/.ko.yaml @@ -0,0 +1,19 @@ +defaultBaseImage: cgr.dev/chainguard/go # For now, we need the go binary in order to format go files. +defaultPlatforms: + - linux/arm64 + - linux/amd64 + +builds: + - id: go-enum + dir: . # default is . + main: . + flags: + - -tags + - netgo + ldflags: + - -s -w + - -extldflags "-static" + - -X "main.version={{.Env.VERSION}}" + - -X "main.commit={{.Env.COMMIT}}" + - -X "main.date={{.Env.DATE}}" + - -X "main.builtBy={{.Env.BUILT_BY}}" diff --git a/Makefile b/Makefile index 99912d97..b23cf471 100644 --- a/Makefile +++ b/Makefile @@ -5,28 +5,35 @@ else .SILENT: endif -GO ?= GO111MODULE=on go -COVERAGEDIR = coverage +GO ?= go +COVERAGEDIR= coverage SERVICE=local -ifdef CIRCLE_WORKING_DIRECTORY - COVERAGEDIR = $(CIRCLE_WORKING_DIRECTORY)/coverage - SERVICE=circle-ci + +ifdef GITHUB_ACTIONS +SERVICE=github-actions endif +DATE := $(shell date -u '+%FT%T%z') +GITHUB_SHA ?= $(shell git rev-parse HEAD) +GITHUB_REF ?= local + +LDFLAGS += -X "main.version=$(GITHUB_REF)" +LDFLAGS += -X "main.commit=$(GITHUB_SHA)" +LDFLAGS += -X "main.date=$(DATE)" +LDFLAGS += -X "main.builtBy=$(USER)" +LDFLAGS += -extldflags '-static' + define goinstall mkdir -p $(shell pwd)/bin echo "Installing $(1)" GOBIN=$(shell pwd)/bin go install $(1) endef -GOBINDATA=bin/go-bindata GOIMPORTS=bin/goimports GOVERALLS=bin/goveralls MOCKGEN=bin/mockgen deps: $(MOCKGEN) -deps: $(GOBINDATA) deps: $(GOIMPORTS) -deps: $(GOVERALLS) PACKAGES='./generator' './example' @@ -36,13 +43,14 @@ all: build fmt test example cover install build: deps $(GO) generate ./generator if [ ! -d bin ]; then mkdir bin; fi - $(GO) build -v -o bin/go-enum . + $(GO) build -v -o bin/go-enum -ldflags='-X "main.version=example" -X "main.commit=example" -X "main.date=example" -X "main.builtBy=example"' . fmt: - gofmt -l -w -s $$(find . -type f -name '*.go' -not -path "./vendor/*") + -$(GO) fmt ./... test: gen-test generate - $(GO) test -v -race -coverprofile=coverage.out ./... + $(GO) test -v -race -shuffle on -coverprofile=coverage.out ./... + $(GO) test -v -race -shuffle on --tags=example ./example cover: gen-test test $(GO) tool cover -html=coverage.out -o coverage.html @@ -52,17 +60,25 @@ coveralls: $(GOVERALLS) $(GOVERALLS) -coverprofile=coverage.out -service=$(SERVICE) -repotoken=$(COVERALLS_TOKEN) clean: - $(GO) clean rm -f bin/go-enum rm -rf coverage/ rm -rf bin/ + rm -rf dist/ + $(GO) clean + +.PHONY: assert-no-changes +assert-no-changes: + @if [ -n "$(shell git status --porcelain)" ]; then \ + echo "git changes found: $(shell git status --porcelain)"; \ + exit 1; \ + fi .PHONY: generate generate: - $(GO) generate $(PACKAGES) + $(GO) generate --tags=example $(PACKAGES) gen-test: build - $(GO) generate $(PACKAGES) + $(GO) generate --tags=example $(PACKAGES) install: $(GO) install @@ -82,5 +98,27 @@ bin/mockgen: go.sum bin/goveralls: go.sum $(call goinstall,github.com/mattn/goveralls) -bin/go-bindata: go.sum - $(call goinstall,github.com/kevinburke/go-bindata/go-bindata) +# snapshots: snapshots_1.17 +snapshots: snapshots_1.21 + +snapshots_%: clean + echo "##### updating snapshots for golang $* #####" + docker run -i -t -w /app -v $(shell pwd):/app --entrypoint /bin/sh golang:$* -c './update-snapshots.sh || true' + +.PHONY: ci +ci: docker_1.20 +ci: docker_1.21 + +docker_%: + echo "##### testing golang $* #####" + docker run -i -t -w /app -v $(shell pwd):/app --entrypoint /bin/sh golang:$* -c 'make clean && make' + +.PHONY: pullimages +pullimages: pullimage_1.20 +pullimages: pullimage_1.21 + +pullimage_%: + docker pull golang:$* + +build_docker: + KO_DOCKER_REPO=abice/go-enum VERSION=$(GITHUB_REF) COMMIT=$(GITHUB_SHA) DATE=$(DATE) BUILT_BY=$(USER) ko build --bare --local diff --git a/README.md b/README.md index 5f6b0262..98417b9c 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # go-enum -[![CircleCI](https://circleci.com/gh/abice/go-enum.svg?style=svg&circle-token=b44c10ce16bcef76e86da801d67811a5ff71fc72)](https://circleci.com/gh/abice/go-enum) +[![Actions Status](https://github.com/abice/go-enum/actions/workflows/build_and_test.yml/badge.svg)](https://github.com/abice/go-enum/actions/workflows/build_and_test.yml) [![Go Report Card](https://goreportcard.com/badge/github.com/abice/go-enum)](https://goreportcard.com/report/github.com/abice/go-enum) [![Coverage Status](https://coveralls.io/repos/github/abice/go-enum/badge.svg)](https://coveralls.io/github/abice/go-enum) [![GoDoc](https://godoc.org/github.com/abice/go-enum?status.svg)](https://godoc.org/github.com/abice/go-enum) @@ -10,37 +10,170 @@ An enum generator for go ## How it works +go-enum will take a commented type declaration like this: + +```go +// ENUM(jpeg, jpg, png, tiff, gif) +type ImageType int +``` + +and generate a file with the iota definition along various optional niceties that you may need: + +```go +const ( + // ImageTypeJpeg is a ImageType of type Jpeg. + ImageTypeJpeg ImageType = iota + // ImageTypeJpg is a ImageType of type Jpg. + ImageTypeJpg + // ImageTypePng is a ImageType of type Png. + ImageTypePng + // ImageTypeTiff is a ImageType of type Tiff. + ImageTypeTiff + // ImageTypeGif is a ImageType of type Gif. + ImageTypeGif +) + +// String implements the Stringer interface. +func (x ImageType) String() string + +// ParseImageType attempts to convert a string to a ImageType. +func ParseImageType(name string) (ImageType, error) + +// MarshalText implements the text marshaller method. +func (x ImageType) MarshalText() ([]byte, error) + +// UnmarshalText implements the text unmarshaller method. +func (x *ImageType) UnmarshalText(text []byte) error +``` + +**Fear not the fact that the `MarshalText` and `UnmarshalText` are generated rather than JSON methods... they will still be utilized by the default JSON encoding methods.** + +If you find that the options given are not adequate for your use case, there is an option to add a custom template (`-t` flag) to the processing engine so that your custom code can be created! + +## Now with string typed enums + +```go +// ENUM(pending, running, completed, failed) +type StrState string +``` + +```go +const ( + // StrStatePending is a StrState of type pending. + StrStatePending StrState = "pending" + // StrStateRunning is a StrState of type running. + StrStateRunning StrState = "running" + // StrStateCompleted is a StrState of type completed. + StrStateCompleted StrState = "completed" + // StrStateFailed is a StrState of type failed. + StrStateFailed StrState = "failed" +) +``` + +If you would like to get integer values in sql, but strings elsewhere, you can assign an int value in the declaration +like always, and specify the `--sqlint` flag. Those values will be then used to convey the int value to sql, while allowing you to use only strings elsewhere. +This might be helpful for things like swagger docs where you want the same type being used on the api layer, as you do in the +sql layer, and not have swagger assume that your enumerations are integers, but are in fact strings! + +```go +// swagger:enum StrState +// ENUM(pending, running, completed, failed) +type StrState string +``` + +## Goal + The goal of go-enum is to create an easy to use enum generator that will take a decorated type declaration like `type EnumName int` and create the associated constant values and funcs that will make life a little easier for adding new values. It's not perfect, but I think it's useful. I took the output of the [Stringer](https://godoc.org/golang.org/x/tools/cmd/stringer) command as the `String()` method, and added a way to parse a string value. +## Docker image + +You can now use a docker image directly for running the command if you do not wish to install anything! + +```shell + docker run -w /app -v $(pwd):/app abice/go-enum:$(GO_ENUM_VERSION) +``` + +## Installation + +You can now download a release directly from github and use that for generating your enums! (Thanks to [GoReleaser](https://github.com/goreleaser/goreleaser-action)) + +I did not specify any overrides on the release binary names, so `uname -s` and `uname -m` should provide the correct version of the binary for your distro. + +```shell + curl -fsSL "https://github.com/abice/go-enum/releases/download/$(GO_ENUM_VERSION)/go-enum_$(uname -s)_$(uname -m)" -o go-enum +``` + +## Adding it to your project + +### Using go generate + +1. Add a go:generate line to your file like so... `//go:generate go-enum --marshal` +1. Run go generate like so `go generate ./...` +1. Enjoy your newly created Enumeration! + +### Using Makefile + +If you prefer makefile stuff, you can always do something like this: + +```Makefile +STANDARD_ENUMS = ./example/animal_enum.go \ + ./example/color_enum.go + +NULLABLE_ENUMS = ./example/sql_enum.go + +$(STANDARD_ENUMS): GO_ENUM_FLAGS=--nocase --marshal --names --ptr +$(NULLABLE_ENUMS): GO_ENUM_FLAGS=--nocase --marshal --names --sqlnullint --ptr + +enums: $(STANDARD_ENUMS) $(NULLABLE_ENUMS) + +# The generator statement for go enum files. Files that invalidate the +# enum file: source file, the binary itself, and this file (in case you want to generate with different flags) +%_enum.go: %.go $(GOENUM) Makefile + $(GOENUM) -f $*.go $(GO_ENUM_FLAGS) +``` + ## Command options ``` shell go-enum --help + NAME: go-enum - An enum generator for go USAGE: go-enum [global options] [arguments...] +VERSION: + example + GLOBAL OPTIONS: - --file value, -f value The file(s) to generate enums. Use more than one flag for more files. - --noprefix Prevents the constants generated from having the Enum as a prefix. (default: false) - --lower Adds lowercase variants of the enum strings for lookup. (default: false) - --nocase Adds case insensitive parsing to the enumeration (forces lower flag). (default: false) - --marshal Adds text (and inherently json) marshalling functions. (default: false) - --sql Adds SQL database scan and value functions. (default: false) - --flag Adds golang flag functions. (default: false) - --prefix value Replaces the prefix with a user one. - --names Generates a 'Names() []string' function, and adds the possible enum values in the error response during parsing (default: false) - --nocamel Removes the snake_case to CamelCase name changing (default: false) - --ptr Adds a pointer method to get a pointer from const values (default: false) - --sqlnullint Adds a Null{{ENUM}} type for marshalling a nullable int value to sql (default: false) - --sqlnullstr Adds a Null{{ENUM}} type for marshalling a nullable string value to sql. If sqlnullint is specified too, it will be Null{{ENUM}}Str (default: false) - --template value, -t value Additional template file(s) to generate enums. Use more than one flag for more files. Templates will be executed in alphabetical order. - --help, -h show help (default: false) + --file value, -f value [ --file value, -f value ] The file(s) to generate enums. Use more than one flag for more files. [$GOFILE] + --noprefix Prevents the constants generated from having the Enum as a prefix. (default: false) + --lower Adds lowercase variants of the enum strings for lookup. (default: false) + --nocase Adds case insensitive parsing to the enumeration (forces lower flag). (default: false) + --marshal Adds text (and inherently json) marshalling functions. (default: false) + --sql Adds SQL database scan and value functions. (default: false) + --sqlint Tells the generator that a string typed enum should be stored in sql as an integer value. (default: false) + --flag Adds golang flag functions. (default: false) + --prefix value Adds a prefix with a user one. If you would like to replace the prefix, then combine this option with --noprefix. + --names Generates a 'Names() []string' function, and adds the possible enum values in the error response during parsing (default: false) + --values Generates a 'Values() []{{ENUM}}' function. (default: false) + --nocamel Removes the snake_case to CamelCase name changing (default: false) + --ptr Adds a pointer method to get a pointer from const values (default: false) + --sqlnullint Adds a Null{{ENUM}} type for marshalling a nullable int value to sql (default: false) + --sqlnullstr Adds a Null{{ENUM}} type for marshalling a nullable string value to sql. If sqlnullint is specified too, it will be Null{{ENUM}}Str (default: false) + --template value, -t value [ --template value, -t value ] Additional template file(s) to generate enums. Use more than one flag for more files. Templates will be executed in alphabetical order. + --alias value, -a value [ --alias value, -a value ] Adds or replaces aliases for a non alphanumeric value that needs to be accounted for. [Format should be "key:value,key2:value2", or specify multiple entries, or both!] + --mustparse Adds a Must version of the Parse that will panic on failure. (default: false) + --forcelower Forces a camel cased comment to generate lowercased names. (default: false) + --forceupper Forces a camel cased comment to generate uppercased names. (default: false) + --nocomments Removes auto generated comments. If you add your own comments, these will still be created. (default: false) + --buildtag value, -b value [ --buildtag value, -b value ] Adds build tags to a generated enum file. + --help, -h show help + --version, -v print the version ``` ### Syntax @@ -49,6 +182,8 @@ The parser looks for comments on your type defs and parse the enum declarations The parser will look for `ENUM(` and continue to look for comma separated values until it finds a `)`. You can put values on the same line, or on multiple lines.\ If you need to have a specific value jump in the enum, you can now specify that by adding `=numericValue` to the enum declaration. Keep in mind, this resets the data for all following values. So if you specify `50` in the middle of an enum, each value after that will be `51, 52, 53...` +[Examples can be found in the example folder](./example/) + #### Comments You can use comments inside enum that start with `//`\ @@ -85,7 +220,7 @@ const ( #### Example -There are a few examples in the `example` [directory](example). +There are a few examples in the `example` [directory](./example/). I've included one here for easy access, but can't guarantee it's up to date. ``` go @@ -108,120 +243,119 @@ type Color int32 The generated code will look something like: ``` go -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example package example import ( - "fmt" - "strings" + "fmt" + "strings" ) const ( - // ColorBlack is a Color of type Black - ColorBlack Color = iota - // ColorWhite is a Color of type White - ColorWhite - // ColorRed is a Color of type Red - ColorRed - // ColorGreen is a Color of type Green - // Green starts with 33 - ColorGreen Color = iota + 30 - // ColorBlue is a Color of type Blue - ColorBlue - // ColorGrey is a Color of type Grey - ColorGrey - // ColorYellow is a Color of type Yellow - ColorYellow - // ColorBlueGreen is a Color of type Blue-Green - ColorBlueGreen - // ColorRedOrange is a Color of type Red-Orange - ColorRedOrange - // ColorYellowGreen is a Color of type Yellow_green - ColorYellowGreen - // ColorRedOrangeBlue is a Color of type Red-Orange-Blue - ColorRedOrangeBlue + // ColorBlack is a Color of type Black. + ColorBlack Color = iota + // ColorWhite is a Color of type White. + ColorWhite + // ColorRed is a Color of type Red. + ColorRed + // ColorGreen is a Color of type Green. + // Green starts with 33 + ColorGreen Color = iota + 30 + // ColorBlue is a Color of type Blue. + ColorBlue + // ColorGrey is a Color of type Grey. + ColorGrey + // ColorYellow is a Color of type Yellow. + ColorYellow + // ColorBlueGreen is a Color of type Blue-Green. + ColorBlueGreen + // ColorRedOrange is a Color of type Red-Orange. + ColorRedOrange + // ColorYellowGreen is a Color of type Yellow_green. + ColorYellowGreen + // ColorRedOrangeBlue is a Color of type Red-Orange-Blue. + ColorRedOrangeBlue ) const _ColorName = "BlackWhiteRedGreenBluegreyyellowblue-greenred-orangeyellow_greenred-orange-blue" var _ColorMap = map[Color]string{ - 0: _ColorName[0:5], - 1: _ColorName[5:10], - 2: _ColorName[10:13], - 33: _ColorName[13:18], - 34: _ColorName[18:22], - 35: _ColorName[22:26], - 36: _ColorName[26:32], - 37: _ColorName[32:42], - 38: _ColorName[42:52], - 39: _ColorName[52:64], - 40: _ColorName[64:79], + ColorBlack: _ColorName[0:5], + ColorWhite: _ColorName[5:10], + ColorRed: _ColorName[10:13], + ColorGreen: _ColorName[13:18], + ColorBlue: _ColorName[18:22], + ColorGrey: _ColorName[22:26], + ColorYellow: _ColorName[26:32], + ColorBlueGreen: _ColorName[32:42], + ColorRedOrange: _ColorName[42:52], + ColorYellowGreen: _ColorName[52:64], + ColorRedOrangeBlue: _ColorName[64:79], } // String implements the Stringer interface. func (x Color) String() string { - if str, ok := _ColorMap[x]; ok { - return str - } - return fmt.Sprintf("Color(%d)", x) + if str, ok := _ColorMap[x]; ok { + return str + } + return fmt.Sprintf("Color(%d)", x) } var _ColorValue = map[string]Color{ - _ColorName[0:5]: 0, - strings.ToLower(_ColorName[0:5]): 0, - _ColorName[5:10]: 1, - strings.ToLower(_ColorName[5:10]): 1, - _ColorName[10:13]: 2, - strings.ToLower(_ColorName[10:13]): 2, - _ColorName[13:18]: 33, - strings.ToLower(_ColorName[13:18]): 33, - _ColorName[18:22]: 34, - strings.ToLower(_ColorName[18:22]): 34, - _ColorName[22:26]: 35, - strings.ToLower(_ColorName[22:26]): 35, - _ColorName[26:32]: 36, - strings.ToLower(_ColorName[26:32]): 36, - _ColorName[32:42]: 37, - strings.ToLower(_ColorName[32:42]): 37, - _ColorName[42:52]: 38, - strings.ToLower(_ColorName[42:52]): 38, - _ColorName[52:64]: 39, - strings.ToLower(_ColorName[52:64]): 39, - _ColorName[64:79]: 40, - strings.ToLower(_ColorName[64:79]): 40, + _ColorName[0:5]: ColorBlack, + strings.ToLower(_ColorName[0:5]): ColorBlack, + _ColorName[5:10]: ColorWhite, + strings.ToLower(_ColorName[5:10]): ColorWhite, + _ColorName[10:13]: ColorRed, + strings.ToLower(_ColorName[10:13]): ColorRed, + _ColorName[13:18]: ColorGreen, + strings.ToLower(_ColorName[13:18]): ColorGreen, + _ColorName[18:22]: ColorBlue, + strings.ToLower(_ColorName[18:22]): ColorBlue, + _ColorName[22:26]: ColorGrey, + strings.ToLower(_ColorName[22:26]): ColorGrey, + _ColorName[26:32]: ColorYellow, + strings.ToLower(_ColorName[26:32]): ColorYellow, + _ColorName[32:42]: ColorBlueGreen, + strings.ToLower(_ColorName[32:42]): ColorBlueGreen, + _ColorName[42:52]: ColorRedOrange, + strings.ToLower(_ColorName[42:52]): ColorRedOrange, + _ColorName[52:64]: ColorYellowGreen, + strings.ToLower(_ColorName[52:64]): ColorYellowGreen, + _ColorName[64:79]: ColorRedOrangeBlue, + strings.ToLower(_ColorName[64:79]): ColorRedOrangeBlue, } // ParseColor attempts to convert a string to a Color func ParseColor(name string) (Color, error) { - if x, ok := _ColorValue[name]; ok { - return x, nil - } - return Color(0), fmt.Errorf("%s is not a valid Color", name) + if x, ok := _ColorValue[name]; ok { + return x, nil + } + return Color(0), fmt.Errorf("%s is not a valid Color", name) +} + +func (x Color) Ptr() *Color { + return &x } // MarshalText implements the text marshaller method func (x Color) MarshalText() ([]byte, error) { - return []byte(x.String()), nil + return []byte(x.String()), nil } // UnmarshalText implements the text unmarshaller method func (x *Color) UnmarshalText(text []byte) error { - name := string(text) - tmp, err := ParseColor(name) - if err != nil { - return err - } - *x = tmp - return nil + name := string(text) + tmp, err := ParseColor(name) + if err != nil { + return err + } + *x = tmp + return nil } - ``` - -## Adding it to your project - -1. `go get github.com/abice/go-enum` -1. Add a go:generate line to your file like so... `//go:generate go-enum -f=$GOFILE --marshal` -1. Run go generate like so `go generate ./...` -1. Enjoy your newly created Enumeration diff --git a/doc.go b/doc.go index 14e96afe..5f36389e 100644 --- a/doc.go +++ b/doc.go @@ -9,21 +9,23 @@ // to skip a value in the enum that won't be an allowed value. // // Installation -// go get github.com/abice/go-enum +// +// go get github.com/abice/go-enum // // Usage: // Sample File -// //go:generate go-enum -f=myenum.go --marshal -- // -// package mypackage +// //go:generate go-enum -f=myenum.go --marshal -- +// +// package mypackage // -// // MyEnum docs here -// // ENUM(Value1, Value2 -// // Value3,_, -// // Value4) -// type MyEnum int +// // MyEnum docs here +// // ENUM(Value1, Value2 +// // Value3,_, +// // Value4) +// type MyEnum int // // Command to generate your enum -// go generate ./ // +// go generate ./ package main diff --git a/example/animal.go b/example/animal.go index 0ffefa2f..c8002613 100644 --- a/example/animal.go +++ b/example/animal.go @@ -1,4 +1,7 @@ -//go:generate ../bin/go-enum -f=$GOFILE +//go:build example +// +build example + +//go:generate ../bin/go-enum -a "+:Plus,#:Sharp" -b example package example @@ -6,5 +9,7 @@ package example // Cat, // Dog, // Fish -// ) +// Fish++ +// Fish# +// ). type Animal int32 diff --git a/example/animal_enum.go b/example/animal_enum.go index ab7ebff1..e69701b7 100644 --- a/example/animal_enum.go +++ b/example/animal_enum.go @@ -1,9 +1,16 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example import ( + "errors" "fmt" ) @@ -14,14 +21,22 @@ const ( AnimalDog // AnimalFish is a Animal of type Fish. AnimalFish + // AnimalFishPlusPlus is a Animal of type Fish++. + AnimalFishPlusPlus + // AnimalFishSharp is a Animal of type Fish#. + AnimalFishSharp ) -const _AnimalName = "CatDogFish" +var ErrInvalidAnimal = errors.New("not a valid Animal") + +const _AnimalName = "CatDogFishFish++Fish#" var _AnimalMap = map[Animal]string{ - 0: _AnimalName[0:3], - 1: _AnimalName[3:6], - 2: _AnimalName[6:10], + AnimalCat: _AnimalName[0:3], + AnimalDog: _AnimalName[3:6], + AnimalFish: _AnimalName[6:10], + AnimalFishPlusPlus: _AnimalName[10:16], + AnimalFishSharp: _AnimalName[16:21], } // String implements the Stringer interface. @@ -32,16 +47,25 @@ func (x Animal) String() string { return fmt.Sprintf("Animal(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Animal) IsValid() bool { + _, ok := _AnimalMap[x] + return ok +} + var _AnimalValue = map[string]Animal{ - _AnimalName[0:3]: 0, - _AnimalName[3:6]: 1, - _AnimalName[6:10]: 2, + _AnimalName[0:3]: AnimalCat, + _AnimalName[3:6]: AnimalDog, + _AnimalName[6:10]: AnimalFish, + _AnimalName[10:16]: AnimalFishPlusPlus, + _AnimalName[16:21]: AnimalFishSharp, } -// ParseAnimal attempts to convert a string to a Animal +// ParseAnimal attempts to convert a string to a Animal. func ParseAnimal(name string) (Animal, error) { if x, ok := _AnimalValue[name]; ok { return x, nil } - return Animal(0), fmt.Errorf("%s is not a valid Animal", name) + return Animal(0), fmt.Errorf("%s is %w", name, ErrInvalidAnimal) } diff --git a/example/animal_test.go b/example/animal_test.go index 472941ea..bb3efe3f 100644 --- a/example/animal_test.go +++ b/example/animal_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( diff --git a/example/color.go b/example/color.go index b0a32b1b..56e587d0 100644 --- a/example/color.go +++ b/example/color.go @@ -1,4 +1,7 @@ -//go:generate ../bin/go-enum -f=$GOFILE --marshal --lower --ptr +//go:build example +// +build example + +//go:generate ../bin/go-enum --marshal --lower --ptr --mustparse -b example package example diff --git a/example/color_enum.go b/example/color_enum.go index f8a32816..c5fcd156 100644 --- a/example/color_enum.go +++ b/example/color_enum.go @@ -1,9 +1,16 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example import ( + "errors" "fmt" "strings" ) @@ -34,20 +41,22 @@ const ( ColorRedOrangeBlue ) +var ErrInvalidColor = errors.New("not a valid Color") + const _ColorName = "BlackWhiteRedGreenBluegreyyellowblue-greenred-orangeyellow_greenred-orange-blue" var _ColorMap = map[Color]string{ - 0: _ColorName[0:5], - 1: _ColorName[5:10], - 2: _ColorName[10:13], - 33: _ColorName[13:18], - 34: _ColorName[18:22], - 35: _ColorName[22:26], - 36: _ColorName[26:32], - 37: _ColorName[32:42], - 38: _ColorName[42:52], - 39: _ColorName[52:64], - 40: _ColorName[64:79], + ColorBlack: _ColorName[0:5], + ColorWhite: _ColorName[5:10], + ColorRed: _ColorName[10:13], + ColorGreen: _ColorName[13:18], + ColorBlue: _ColorName[18:22], + ColorGrey: _ColorName[22:26], + ColorYellow: _ColorName[26:32], + ColorBlueGreen: _ColorName[32:42], + ColorRedOrange: _ColorName[42:52], + ColorYellowGreen: _ColorName[52:64], + ColorRedOrangeBlue: _ColorName[64:79], } // String implements the Stringer interface. @@ -58,49 +67,65 @@ func (x Color) String() string { return fmt.Sprintf("Color(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Color) IsValid() bool { + _, ok := _ColorMap[x] + return ok +} + var _ColorValue = map[string]Color{ - _ColorName[0:5]: 0, - strings.ToLower(_ColorName[0:5]): 0, - _ColorName[5:10]: 1, - strings.ToLower(_ColorName[5:10]): 1, - _ColorName[10:13]: 2, - strings.ToLower(_ColorName[10:13]): 2, - _ColorName[13:18]: 33, - strings.ToLower(_ColorName[13:18]): 33, - _ColorName[18:22]: 34, - strings.ToLower(_ColorName[18:22]): 34, - _ColorName[22:26]: 35, - strings.ToLower(_ColorName[22:26]): 35, - _ColorName[26:32]: 36, - strings.ToLower(_ColorName[26:32]): 36, - _ColorName[32:42]: 37, - strings.ToLower(_ColorName[32:42]): 37, - _ColorName[42:52]: 38, - strings.ToLower(_ColorName[42:52]): 38, - _ColorName[52:64]: 39, - strings.ToLower(_ColorName[52:64]): 39, - _ColorName[64:79]: 40, - strings.ToLower(_ColorName[64:79]): 40, + _ColorName[0:5]: ColorBlack, + strings.ToLower(_ColorName[0:5]): ColorBlack, + _ColorName[5:10]: ColorWhite, + strings.ToLower(_ColorName[5:10]): ColorWhite, + _ColorName[10:13]: ColorRed, + strings.ToLower(_ColorName[10:13]): ColorRed, + _ColorName[13:18]: ColorGreen, + strings.ToLower(_ColorName[13:18]): ColorGreen, + _ColorName[18:22]: ColorBlue, + strings.ToLower(_ColorName[18:22]): ColorBlue, + _ColorName[22:26]: ColorGrey, + strings.ToLower(_ColorName[22:26]): ColorGrey, + _ColorName[26:32]: ColorYellow, + strings.ToLower(_ColorName[26:32]): ColorYellow, + _ColorName[32:42]: ColorBlueGreen, + strings.ToLower(_ColorName[32:42]): ColorBlueGreen, + _ColorName[42:52]: ColorRedOrange, + strings.ToLower(_ColorName[42:52]): ColorRedOrange, + _ColorName[52:64]: ColorYellowGreen, + strings.ToLower(_ColorName[52:64]): ColorYellowGreen, + _ColorName[64:79]: ColorRedOrangeBlue, + strings.ToLower(_ColorName[64:79]): ColorRedOrangeBlue, } -// ParseColor attempts to convert a string to a Color +// ParseColor attempts to convert a string to a Color. func ParseColor(name string) (Color, error) { if x, ok := _ColorValue[name]; ok { return x, nil } - return Color(0), fmt.Errorf("%s is not a valid Color", name) + return Color(0), fmt.Errorf("%s is %w", name, ErrInvalidColor) +} + +// MustParseColor converts a string to a Color, and panics if is not valid. +func MustParseColor(name string) Color { + val, err := ParseColor(name) + if err != nil { + panic(err) + } + return val } func (x Color) Ptr() *Color { return &x } -// MarshalText implements the text marshaller method +// MarshalText implements the text marshaller method. func (x Color) MarshalText() ([]byte, error) { return []byte(x.String()), nil } -// UnmarshalText implements the text unmarshaller method +// UnmarshalText implements the text unmarshaller method. func (x *Color) UnmarshalText(text []byte) error { name := string(text) tmp, err := ParseColor(name) diff --git a/example/color_test.go b/example/color_test.go index bb2ef35e..4853bdc6 100644 --- a/example/color_test.go +++ b/example/color_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( @@ -23,6 +26,13 @@ func TestColorString(t *testing.T) { assert.Equal(t, &x, Color(109).Ptr()) } +func TestColorMustParse(t *testing.T) { + x := `avocadogreen` + + assert.PanicsWithError(t, x+" is not a valid Color", func() { MustParseColor(x) }) + assert.NotPanics(t, func() { MustParseColor(ColorGreen.String()) }) +} + func TestColorUnmarshal(t *testing.T) { tests := []struct { name string @@ -229,7 +239,6 @@ func TestColorMarshal(t *testing.T) { } func BenchmarkColorParse(b *testing.B) { - knownItems := []string{ ColorRedOrangeBlue.String(), strings.ToLower(ColorRedOrangeBlue.String()), @@ -247,5 +256,4 @@ func BenchmarkColorParse(b *testing.B) { } }) } - } diff --git a/example/commented.go b/example/commented.go index d45b5ef9..423a852e 100644 --- a/example/commented.go +++ b/example/commented.go @@ -1,4 +1,4 @@ -//go:generate ../bin/go-enum -f=$GOFILE --marshal --lower +//go:generate ../bin/go-enum --marshal --lower -b example package example diff --git a/example/commented_enum.go b/example/commented_enum.go index fc39f6d6..be3f3fc6 100644 --- a/example/commented_enum.go +++ b/example/commented_enum.go @@ -1,9 +1,16 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example import ( + "errors" "fmt" "strings" ) @@ -19,12 +26,14 @@ const ( CommentedValue3 ) +var ErrInvalidCommented = errors.New("not a valid Commented") + const _CommentedName = "value1value2value3" var _CommentedMap = map[Commented]string{ - 0: _CommentedName[0:6], - 1: _CommentedName[6:12], - 2: _CommentedName[12:18], + CommentedValue1: _CommentedName[0:6], + CommentedValue2: _CommentedName[6:12], + CommentedValue3: _CommentedName[12:18], } // String implements the Stringer interface. @@ -35,29 +44,36 @@ func (x Commented) String() string { return fmt.Sprintf("Commented(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Commented) IsValid() bool { + _, ok := _CommentedMap[x] + return ok +} + var _CommentedValue = map[string]Commented{ - _CommentedName[0:6]: 0, - strings.ToLower(_CommentedName[0:6]): 0, - _CommentedName[6:12]: 1, - strings.ToLower(_CommentedName[6:12]): 1, - _CommentedName[12:18]: 2, - strings.ToLower(_CommentedName[12:18]): 2, + _CommentedName[0:6]: CommentedValue1, + strings.ToLower(_CommentedName[0:6]): CommentedValue1, + _CommentedName[6:12]: CommentedValue2, + strings.ToLower(_CommentedName[6:12]): CommentedValue2, + _CommentedName[12:18]: CommentedValue3, + strings.ToLower(_CommentedName[12:18]): CommentedValue3, } -// ParseCommented attempts to convert a string to a Commented +// ParseCommented attempts to convert a string to a Commented. func ParseCommented(name string) (Commented, error) { if x, ok := _CommentedValue[name]; ok { return x, nil } - return Commented(0), fmt.Errorf("%s is not a valid Commented", name) + return Commented(0), fmt.Errorf("%s is %w", name, ErrInvalidCommented) } -// MarshalText implements the text marshaller method +// MarshalText implements the text marshaller method. func (x Commented) MarshalText() ([]byte, error) { return []byte(x.String()), nil } -// UnmarshalText implements the text unmarshaller method +// UnmarshalText implements the text unmarshaller method. func (x *Commented) UnmarshalText(text []byte) error { name := string(text) tmp, err := ParseCommented(name) @@ -82,12 +98,14 @@ const ( ComplexCommentedValue3 ) +var ErrInvalidComplexCommented = errors.New("not a valid ComplexCommented") + const _ComplexCommentedName = "value1value2value3" var _ComplexCommentedMap = map[ComplexCommented]string{ - 1: _ComplexCommentedName[0:6], - 2: _ComplexCommentedName[6:12], - 3: _ComplexCommentedName[12:18], + ComplexCommentedValue1: _ComplexCommentedName[0:6], + ComplexCommentedValue2: _ComplexCommentedName[6:12], + ComplexCommentedValue3: _ComplexCommentedName[12:18], } // String implements the Stringer interface. @@ -98,29 +116,36 @@ func (x ComplexCommented) String() string { return fmt.Sprintf("ComplexCommented(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x ComplexCommented) IsValid() bool { + _, ok := _ComplexCommentedMap[x] + return ok +} + var _ComplexCommentedValue = map[string]ComplexCommented{ - _ComplexCommentedName[0:6]: 1, - strings.ToLower(_ComplexCommentedName[0:6]): 1, - _ComplexCommentedName[6:12]: 2, - strings.ToLower(_ComplexCommentedName[6:12]): 2, - _ComplexCommentedName[12:18]: 3, - strings.ToLower(_ComplexCommentedName[12:18]): 3, + _ComplexCommentedName[0:6]: ComplexCommentedValue1, + strings.ToLower(_ComplexCommentedName[0:6]): ComplexCommentedValue1, + _ComplexCommentedName[6:12]: ComplexCommentedValue2, + strings.ToLower(_ComplexCommentedName[6:12]): ComplexCommentedValue2, + _ComplexCommentedName[12:18]: ComplexCommentedValue3, + strings.ToLower(_ComplexCommentedName[12:18]): ComplexCommentedValue3, } -// ParseComplexCommented attempts to convert a string to a ComplexCommented +// ParseComplexCommented attempts to convert a string to a ComplexCommented. func ParseComplexCommented(name string) (ComplexCommented, error) { if x, ok := _ComplexCommentedValue[name]; ok { return x, nil } - return ComplexCommented(0), fmt.Errorf("%s is not a valid ComplexCommented", name) + return ComplexCommented(0), fmt.Errorf("%s is %w", name, ErrInvalidComplexCommented) } -// MarshalText implements the text marshaller method +// MarshalText implements the text marshaller method. func (x ComplexCommented) MarshalText() ([]byte, error) { return []byte(x.String()), nil } -// UnmarshalText implements the text unmarshaller method +// UnmarshalText implements the text unmarshaller method. func (x *ComplexCommented) UnmarshalText(text []byte) error { name := string(text) tmp, err := ParseComplexCommented(name) diff --git a/example/commented_test.go b/example/commented_test.go index c43fe536..e4639ffd 100644 --- a/example/commented_test.go +++ b/example/commented_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( diff --git a/example/custom_prefix.go b/example/custom_prefix.go index 02f0fd7d..c63403b4 100644 --- a/example/custom_prefix.go +++ b/example/custom_prefix.go @@ -1,4 +1,4 @@ -//go:generate ../bin/go-enum -f=$GOFILE --prefix=AcmeInc +//go:generate ../bin/go-enum --prefix=AcmeInc -b example package example diff --git a/example/custom_prefix_enum.go b/example/custom_prefix_enum.go index 40a3a4c0..a153fe91 100644 --- a/example/custom_prefix_enum.go +++ b/example/custom_prefix_enum.go @@ -1,9 +1,16 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example import ( + "errors" "fmt" ) @@ -16,12 +23,14 @@ const ( AcmeIncProductGlue ) +var ErrInvalidProduct = errors.New("not a valid Product") + const _ProductName = "AnvilDynamiteGlue" var _ProductMap = map[Product]string{ - 0: _ProductName[0:5], - 1: _ProductName[5:13], - 2: _ProductName[13:17], + AcmeIncProductAnvil: _ProductName[0:5], + AcmeIncProductDynamite: _ProductName[5:13], + AcmeIncProductGlue: _ProductName[13:17], } // String implements the Stringer interface. @@ -32,16 +41,23 @@ func (x Product) String() string { return fmt.Sprintf("Product(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Product) IsValid() bool { + _, ok := _ProductMap[x] + return ok +} + var _ProductValue = map[string]Product{ - _ProductName[0:5]: 0, - _ProductName[5:13]: 1, - _ProductName[13:17]: 2, + _ProductName[0:5]: AcmeIncProductAnvil, + _ProductName[5:13]: AcmeIncProductDynamite, + _ProductName[13:17]: AcmeIncProductGlue, } -// ParseProduct attempts to convert a string to a Product +// ParseProduct attempts to convert a string to a Product. func ParseProduct(name string) (Product, error) { if x, ok := _ProductValue[name]; ok { return x, nil } - return Product(0), fmt.Errorf("%s is not a valid Product", name) + return Product(0), fmt.Errorf("%s is %w", name, ErrInvalidProduct) } diff --git a/example/custom_prefix_test.go b/example/custom_prefix_test.go index efd16306..12b17577 100644 --- a/example/custom_prefix_test.go +++ b/example/custom_prefix_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( diff --git a/example/diff_base.go b/example/diff_base.go new file mode 100644 index 00000000..860d4cc2 --- /dev/null +++ b/example/diff_base.go @@ -0,0 +1,20 @@ +package example + +//go:generate ../bin/go-enum --forcelower -b example + +/* +ENUM( + + B3 = 03 + B4 = 04 + B5 = 5 + B6 = 0b110 + B7 = 0b111 + B8 = 0x08 + B9 = 0x09 + B10 = 0x0B + B11 = 0x2B + +) +*/ +type DiffBase int diff --git a/example/diff_base_enum.go b/example/diff_base_enum.go new file mode 100644 index 00000000..050758d1 --- /dev/null +++ b/example/diff_base_enum.go @@ -0,0 +1,87 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "errors" + "fmt" +) + +const ( + // DiffBaseB3 is a DiffBase of type B3. + DiffBaseB3 DiffBase = iota + 3 + // DiffBaseB4 is a DiffBase of type B4. + DiffBaseB4 + // DiffBaseB5 is a DiffBase of type B5. + DiffBaseB5 + // DiffBaseB6 is a DiffBase of type B6. + DiffBaseB6 + // DiffBaseB7 is a DiffBase of type B7. + DiffBaseB7 + // DiffBaseB8 is a DiffBase of type B8. + DiffBaseB8 + // DiffBaseB9 is a DiffBase of type B9. + DiffBaseB9 + // DiffBaseB10 is a DiffBase of type B10. + DiffBaseB10 DiffBase = iota + 4 + // DiffBaseB11 is a DiffBase of type B11. + DiffBaseB11 DiffBase = iota + 35 +) + +var ErrInvalidDiffBase = errors.New("not a valid DiffBase") + +const _DiffBaseName = "b3b4b5b6b7b8b9b10b11" + +var _DiffBaseMap = map[DiffBase]string{ + DiffBaseB3: _DiffBaseName[0:2], + DiffBaseB4: _DiffBaseName[2:4], + DiffBaseB5: _DiffBaseName[4:6], + DiffBaseB6: _DiffBaseName[6:8], + DiffBaseB7: _DiffBaseName[8:10], + DiffBaseB8: _DiffBaseName[10:12], + DiffBaseB9: _DiffBaseName[12:14], + DiffBaseB10: _DiffBaseName[14:17], + DiffBaseB11: _DiffBaseName[17:20], +} + +// String implements the Stringer interface. +func (x DiffBase) String() string { + if str, ok := _DiffBaseMap[x]; ok { + return str + } + return fmt.Sprintf("DiffBase(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x DiffBase) IsValid() bool { + _, ok := _DiffBaseMap[x] + return ok +} + +var _DiffBaseValue = map[string]DiffBase{ + _DiffBaseName[0:2]: DiffBaseB3, + _DiffBaseName[2:4]: DiffBaseB4, + _DiffBaseName[4:6]: DiffBaseB5, + _DiffBaseName[6:8]: DiffBaseB6, + _DiffBaseName[8:10]: DiffBaseB7, + _DiffBaseName[10:12]: DiffBaseB8, + _DiffBaseName[12:14]: DiffBaseB9, + _DiffBaseName[14:17]: DiffBaseB10, + _DiffBaseName[17:20]: DiffBaseB11, +} + +// ParseDiffBase attempts to convert a string to a DiffBase. +func ParseDiffBase(name string) (DiffBase, error) { + if x, ok := _DiffBaseValue[name]; ok { + return x, nil + } + return DiffBase(0), fmt.Errorf("%s is %w", name, ErrInvalidDiffBase) +} diff --git a/example/diff_base_test.go b/example/diff_base_test.go new file mode 100644 index 00000000..9f5625b8 --- /dev/null +++ b/example/diff_base_test.go @@ -0,0 +1,60 @@ +//go:build example +// +build example + +package example + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestDiffBase(t *testing.T) { + tests := map[string]struct { + actual int + expected DiffBase + }{ + "DiffBaseB3": { + actual: 3, + expected: DiffBaseB3, + }, + "DiffBaseB4": { + actual: 4, + expected: DiffBaseB4, + }, + "DiffBaseB5": { + actual: 5, + expected: DiffBaseB5, + }, + "DiffBaseB6": { + actual: 6, + expected: DiffBaseB6, + }, + "DiffBaseB7": { + actual: 7, + expected: DiffBaseB7, + }, + "DiffBaseB8": { + actual: 8, + expected: DiffBaseB8, + }, + "DiffBaseB9": { + actual: 9, + expected: DiffBaseB9, + }, + "DiffBaseB10": { + actual: 11, + expected: DiffBaseB10, + }, + "DiffBaseB11": { + actual: 43, + expected: DiffBaseB11, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + assert.Equal(t, int(tc.expected), tc.actual) + }) + } +} diff --git a/example/enum_32_bit.go b/example/enum_32_bit.go new file mode 100644 index 00000000..07312cd1 --- /dev/null +++ b/example/enum_32_bit.go @@ -0,0 +1,23 @@ +//go:generate ../bin/go-enum --names -b example + +package example + +/* +ENUM( + +Unkno = 0 +E2P15 = 32768 +E2P16 = 65536 +E2P17 = 131072 +E2P18 = 262144 +E2P19 = 524288 +E2P20 = 1048576 +E2P21 = 2097152 +E2P22 = 33554432 +E2P23 = 67108864 +E2P28 = 536870912 +E2P30 = 1073741824 + +) +*/ +type Enum32bit uint32 diff --git a/example/enum_32_bit_enum.go b/example/enum_32_bit_enum.go new file mode 100644 index 00000000..9a773bd4 --- /dev/null +++ b/example/enum_32_bit_enum.go @@ -0,0 +1,121 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "fmt" + "strings" +) + +const ( + // Enum32bitUnkno is a Enum32bit of type Unkno. + Enum32bitUnkno Enum32bit = iota + // Enum32bitE2P15 is a Enum32bit of type E2P15. + Enum32bitE2P15 Enum32bit = iota + 32767 + // Enum32bitE2P16 is a Enum32bit of type E2P16. + Enum32bitE2P16 Enum32bit = iota + 65534 + // Enum32bitE2P17 is a Enum32bit of type E2P17. + Enum32bitE2P17 Enum32bit = iota + 131069 + // Enum32bitE2P18 is a Enum32bit of type E2P18. + Enum32bitE2P18 Enum32bit = iota + 262140 + // Enum32bitE2P19 is a Enum32bit of type E2P19. + Enum32bitE2P19 Enum32bit = iota + 524283 + // Enum32bitE2P20 is a Enum32bit of type E2P20. + Enum32bitE2P20 Enum32bit = iota + 1048570 + // Enum32bitE2P21 is a Enum32bit of type E2P21. + Enum32bitE2P21 Enum32bit = iota + 2097145 + // Enum32bitE2P22 is a Enum32bit of type E2P22. + Enum32bitE2P22 Enum32bit = iota + 33554424 + // Enum32bitE2P23 is a Enum32bit of type E2P23. + Enum32bitE2P23 Enum32bit = iota + 67108855 + // Enum32bitE2P28 is a Enum32bit of type E2P28. + Enum32bitE2P28 Enum32bit = iota + 536870902 + // Enum32bitE2P30 is a Enum32bit of type E2P30. + Enum32bitE2P30 Enum32bit = iota + 1073741813 +) + +var ErrInvalidEnum32bit = fmt.Errorf("not a valid Enum32bit, try [%s]", strings.Join(_Enum32bitNames, ", ")) + +const _Enum32bitName = "UnknoE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30" + +var _Enum32bitNames = []string{ + _Enum32bitName[0:5], + _Enum32bitName[5:10], + _Enum32bitName[10:15], + _Enum32bitName[15:20], + _Enum32bitName[20:25], + _Enum32bitName[25:30], + _Enum32bitName[30:35], + _Enum32bitName[35:40], + _Enum32bitName[40:45], + _Enum32bitName[45:50], + _Enum32bitName[50:55], + _Enum32bitName[55:60], +} + +// Enum32bitNames returns a list of possible string values of Enum32bit. +func Enum32bitNames() []string { + tmp := make([]string, len(_Enum32bitNames)) + copy(tmp, _Enum32bitNames) + return tmp +} + +var _Enum32bitMap = map[Enum32bit]string{ + Enum32bitUnkno: _Enum32bitName[0:5], + Enum32bitE2P15: _Enum32bitName[5:10], + Enum32bitE2P16: _Enum32bitName[10:15], + Enum32bitE2P17: _Enum32bitName[15:20], + Enum32bitE2P18: _Enum32bitName[20:25], + Enum32bitE2P19: _Enum32bitName[25:30], + Enum32bitE2P20: _Enum32bitName[30:35], + Enum32bitE2P21: _Enum32bitName[35:40], + Enum32bitE2P22: _Enum32bitName[40:45], + Enum32bitE2P23: _Enum32bitName[45:50], + Enum32bitE2P28: _Enum32bitName[50:55], + Enum32bitE2P30: _Enum32bitName[55:60], +} + +// String implements the Stringer interface. +func (x Enum32bit) String() string { + if str, ok := _Enum32bitMap[x]; ok { + return str + } + return fmt.Sprintf("Enum32bit(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Enum32bit) IsValid() bool { + _, ok := _Enum32bitMap[x] + return ok +} + +var _Enum32bitValue = map[string]Enum32bit{ + _Enum32bitName[0:5]: Enum32bitUnkno, + _Enum32bitName[5:10]: Enum32bitE2P15, + _Enum32bitName[10:15]: Enum32bitE2P16, + _Enum32bitName[15:20]: Enum32bitE2P17, + _Enum32bitName[20:25]: Enum32bitE2P18, + _Enum32bitName[25:30]: Enum32bitE2P19, + _Enum32bitName[30:35]: Enum32bitE2P20, + _Enum32bitName[35:40]: Enum32bitE2P21, + _Enum32bitName[40:45]: Enum32bitE2P22, + _Enum32bitName[45:50]: Enum32bitE2P23, + _Enum32bitName[50:55]: Enum32bitE2P28, + _Enum32bitName[55:60]: Enum32bitE2P30, +} + +// ParseEnum32bit attempts to convert a string to a Enum32bit. +func ParseEnum32bit(name string) (Enum32bit, error) { + if x, ok := _Enum32bitValue[name]; ok { + return x, nil + } + return Enum32bit(0), fmt.Errorf("%s is %w", name, ErrInvalidEnum32bit) +} diff --git a/example/enum_32_bit_test.go b/example/enum_32_bit_test.go new file mode 100644 index 00000000..cb3e8d9e --- /dev/null +++ b/example/enum_32_bit_test.go @@ -0,0 +1,46 @@ +//go:build example +// +build example + +package example + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestEnum32Bit(t *testing.T) { + tests := map[string]struct { + input string + output Enum32bit + }{ + "E2P15": { + input: `E2P15`, + output: Enum32bitE2P15, + }, + "E2P30": { + input: `E2P30`, + output: Enum32bitE2P30, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + output, err := ParseEnum32bit(tc.input) + assert.NoError(t, err) + assert.Equal(t, tc.output, output) + + assert.Equal(t, tc.input, output.String()) + }) + } + + t.Run("basics", func(t *testing.T) { + assert.Equal(t, "E2P23", Enum32bitE2P23.String()) + assert.Equal(t, "Enum32bit(99)", Enum32bit(99).String()) + _, err := ParseEnum32bit("-1") + assert.Error(t, err) + + names := Enum32bitNames() + assert.Len(t, names, 12) + }) +} diff --git a/example/enum_64_bit.go b/example/enum_64_bit.go new file mode 100644 index 00000000..6e31b73b --- /dev/null +++ b/example/enum_64_bit.go @@ -0,0 +1,25 @@ +//go:generate ../bin/go-enum --names -b example + +package example + +/* +ENUM( +Unkno = 0 +E2P15 = 32768 +E2P16 = 65536 +E2P17 = 131072 +E2P18 = 262144 +E2P19 = 524288 +E2P20 = 1048576 +E2P21 = 2097152 +E2P22 = 33554432 +E2P23 = 67108864 +E2P28 = 536870912 +E2P30 = 1073741824 +E2P31 = 2147483648 +E2P32 = 4294967296 +E2P33 = 8454967296 +E2P63 = 18446744073709551615 +) +*/ +type Enum64bit uint64 diff --git a/example/enum_64_bit_enum.go b/example/enum_64_bit_enum.go new file mode 100644 index 00000000..caeeccc7 --- /dev/null +++ b/example/enum_64_bit_enum.go @@ -0,0 +1,141 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "fmt" + "strings" +) + +const ( + // Enum64bitUnkno is a Enum64bit of type Unkno. + Enum64bitUnkno Enum64bit = iota + // Enum64bitE2P15 is a Enum64bit of type E2P15. + Enum64bitE2P15 Enum64bit = iota + 32767 + // Enum64bitE2P16 is a Enum64bit of type E2P16. + Enum64bitE2P16 Enum64bit = iota + 65534 + // Enum64bitE2P17 is a Enum64bit of type E2P17. + Enum64bitE2P17 Enum64bit = iota + 131069 + // Enum64bitE2P18 is a Enum64bit of type E2P18. + Enum64bitE2P18 Enum64bit = iota + 262140 + // Enum64bitE2P19 is a Enum64bit of type E2P19. + Enum64bitE2P19 Enum64bit = iota + 524283 + // Enum64bitE2P20 is a Enum64bit of type E2P20. + Enum64bitE2P20 Enum64bit = iota + 1048570 + // Enum64bitE2P21 is a Enum64bit of type E2P21. + Enum64bitE2P21 Enum64bit = iota + 2097145 + // Enum64bitE2P22 is a Enum64bit of type E2P22. + Enum64bitE2P22 Enum64bit = iota + 33554424 + // Enum64bitE2P23 is a Enum64bit of type E2P23. + Enum64bitE2P23 Enum64bit = iota + 67108855 + // Enum64bitE2P28 is a Enum64bit of type E2P28. + Enum64bitE2P28 Enum64bit = iota + 536870902 + // Enum64bitE2P30 is a Enum64bit of type E2P30. + Enum64bitE2P30 Enum64bit = iota + 1073741813 + // Enum64bitE2P31 is a Enum64bit of type E2P31. + Enum64bitE2P31 Enum64bit = iota + 2147483636 + // Enum64bitE2P32 is a Enum64bit of type E2P32. + Enum64bitE2P32 Enum64bit = iota + 4294967283 + // Enum64bitE2P33 is a Enum64bit of type E2P33. + Enum64bitE2P33 Enum64bit = iota + 8454967282 + // Enum64bitE2P63 is a Enum64bit of type E2P63. + Enum64bitE2P63 Enum64bit = iota + 18446744073709551600 +) + +var ErrInvalidEnum64bit = fmt.Errorf("not a valid Enum64bit, try [%s]", strings.Join(_Enum64bitNames, ", ")) + +const _Enum64bitName = "UnknoE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33E2P63" + +var _Enum64bitNames = []string{ + _Enum64bitName[0:5], + _Enum64bitName[5:10], + _Enum64bitName[10:15], + _Enum64bitName[15:20], + _Enum64bitName[20:25], + _Enum64bitName[25:30], + _Enum64bitName[30:35], + _Enum64bitName[35:40], + _Enum64bitName[40:45], + _Enum64bitName[45:50], + _Enum64bitName[50:55], + _Enum64bitName[55:60], + _Enum64bitName[60:65], + _Enum64bitName[65:70], + _Enum64bitName[70:75], + _Enum64bitName[75:80], +} + +// Enum64bitNames returns a list of possible string values of Enum64bit. +func Enum64bitNames() []string { + tmp := make([]string, len(_Enum64bitNames)) + copy(tmp, _Enum64bitNames) + return tmp +} + +var _Enum64bitMap = map[Enum64bit]string{ + Enum64bitUnkno: _Enum64bitName[0:5], + Enum64bitE2P15: _Enum64bitName[5:10], + Enum64bitE2P16: _Enum64bitName[10:15], + Enum64bitE2P17: _Enum64bitName[15:20], + Enum64bitE2P18: _Enum64bitName[20:25], + Enum64bitE2P19: _Enum64bitName[25:30], + Enum64bitE2P20: _Enum64bitName[30:35], + Enum64bitE2P21: _Enum64bitName[35:40], + Enum64bitE2P22: _Enum64bitName[40:45], + Enum64bitE2P23: _Enum64bitName[45:50], + Enum64bitE2P28: _Enum64bitName[50:55], + Enum64bitE2P30: _Enum64bitName[55:60], + Enum64bitE2P31: _Enum64bitName[60:65], + Enum64bitE2P32: _Enum64bitName[65:70], + Enum64bitE2P33: _Enum64bitName[70:75], + Enum64bitE2P63: _Enum64bitName[75:80], +} + +// String implements the Stringer interface. +func (x Enum64bit) String() string { + if str, ok := _Enum64bitMap[x]; ok { + return str + } + return fmt.Sprintf("Enum64bit(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Enum64bit) IsValid() bool { + _, ok := _Enum64bitMap[x] + return ok +} + +var _Enum64bitValue = map[string]Enum64bit{ + _Enum64bitName[0:5]: Enum64bitUnkno, + _Enum64bitName[5:10]: Enum64bitE2P15, + _Enum64bitName[10:15]: Enum64bitE2P16, + _Enum64bitName[15:20]: Enum64bitE2P17, + _Enum64bitName[20:25]: Enum64bitE2P18, + _Enum64bitName[25:30]: Enum64bitE2P19, + _Enum64bitName[30:35]: Enum64bitE2P20, + _Enum64bitName[35:40]: Enum64bitE2P21, + _Enum64bitName[40:45]: Enum64bitE2P22, + _Enum64bitName[45:50]: Enum64bitE2P23, + _Enum64bitName[50:55]: Enum64bitE2P28, + _Enum64bitName[55:60]: Enum64bitE2P30, + _Enum64bitName[60:65]: Enum64bitE2P31, + _Enum64bitName[65:70]: Enum64bitE2P32, + _Enum64bitName[70:75]: Enum64bitE2P33, + _Enum64bitName[75:80]: Enum64bitE2P63, +} + +// ParseEnum64bit attempts to convert a string to a Enum64bit. +func ParseEnum64bit(name string) (Enum64bit, error) { + if x, ok := _Enum64bitValue[name]; ok { + return x, nil + } + return Enum64bit(0), fmt.Errorf("%s is %w", name, ErrInvalidEnum64bit) +} diff --git a/example/enum_64_bit_test.go b/example/enum_64_bit_test.go new file mode 100644 index 00000000..0e2e2bcb --- /dev/null +++ b/example/enum_64_bit_test.go @@ -0,0 +1,46 @@ +//go:build example +// +build example + +package example + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestEnum64Bit(t *testing.T) { + tests := map[string]struct { + input string + output Enum64bit + }{ + "E2P15": { + input: `E2P15`, + output: Enum64bitE2P15, + }, + "E2P63": { + input: `E2P63`, + output: Enum64bitE2P63, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + output, err := ParseEnum64bit(tc.input) + assert.NoError(t, err) + assert.Equal(t, tc.output, output) + + assert.Equal(t, tc.input, output.String()) + }) + } + + t.Run("basics", func(t *testing.T) { + assert.Equal(t, "E2P23", Enum64bitE2P23.String()) + assert.Equal(t, "Enum64bit(99)", Enum64bit(99).String()) + _, err := ParseEnum64bit("-1") + assert.Error(t, err) + + names := Enum64bitNames() + assert.Len(t, names, 16) + }) +} diff --git a/example/example.go b/example/example.go index 1f60dec1..30a154d2 100644 --- a/example/example.go +++ b/example/example.go @@ -1,10 +1,9 @@ -//go:generate ../bin/go-enum -f=$GOFILE --marshal --nocase --flag --names +//go:generate ../bin/go-enum --marshal --nocase --flag --names --values -b example package example // X is doc'ed -type X struct { -} +type X struct{} // Make x ENUM(Toyota,_,Chevy,_,Ford,_,Tesla,_,Hyundai,_,Nissan,_,Jaguar,_,Audi,_,BMW,_,Mercedes-Benz,_,Volkswagon) type Make int32 diff --git a/example/example_enum.go b/example/example_enum.go index 5643cf0c..7035c7ce 100644 --- a/example/example_enum.go +++ b/example/example_enum.go @@ -1,5 +1,11 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example @@ -53,6 +59,8 @@ const ( MakeVolkswagon ) +var ErrInvalidMake = fmt.Errorf("not a valid Make, try [%s]", strings.Join(_MakeNames, ", ")) + const _MakeName = "ToyotaChevyFordTeslaHyundaiNissanJaguarAudiBMWMercedes-BenzVolkswagon" var _MakeNames = []string{ @@ -76,18 +84,35 @@ func MakeNames() []string { return tmp } +// MakeValues returns a list of the values for Make +func MakeValues() []Make { + return []Make{ + MakeToyota, + MakeChevy, + MakeFord, + MakeTesla, + MakeHyundai, + MakeNissan, + MakeJaguar, + MakeAudi, + MakeBMW, + MakeMercedesBenz, + MakeVolkswagon, + } +} + var _MakeMap = map[Make]string{ - 0: _MakeName[0:6], - 2: _MakeName[6:11], - 4: _MakeName[11:15], - 6: _MakeName[15:20], - 8: _MakeName[20:27], - 10: _MakeName[27:33], - 12: _MakeName[33:39], - 14: _MakeName[39:43], - 16: _MakeName[43:46], - 18: _MakeName[46:59], - 20: _MakeName[59:69], + MakeToyota: _MakeName[0:6], + MakeChevy: _MakeName[6:11], + MakeFord: _MakeName[11:15], + MakeTesla: _MakeName[15:20], + MakeHyundai: _MakeName[20:27], + MakeNissan: _MakeName[27:33], + MakeJaguar: _MakeName[33:39], + MakeAudi: _MakeName[39:43], + MakeBMW: _MakeName[43:46], + MakeMercedesBenz: _MakeName[46:59], + MakeVolkswagon: _MakeName[59:69], } // String implements the Stringer interface. @@ -98,32 +123,39 @@ func (x Make) String() string { return fmt.Sprintf("Make(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Make) IsValid() bool { + _, ok := _MakeMap[x] + return ok +} + var _MakeValue = map[string]Make{ - _MakeName[0:6]: 0, - strings.ToLower(_MakeName[0:6]): 0, - _MakeName[6:11]: 2, - strings.ToLower(_MakeName[6:11]): 2, - _MakeName[11:15]: 4, - strings.ToLower(_MakeName[11:15]): 4, - _MakeName[15:20]: 6, - strings.ToLower(_MakeName[15:20]): 6, - _MakeName[20:27]: 8, - strings.ToLower(_MakeName[20:27]): 8, - _MakeName[27:33]: 10, - strings.ToLower(_MakeName[27:33]): 10, - _MakeName[33:39]: 12, - strings.ToLower(_MakeName[33:39]): 12, - _MakeName[39:43]: 14, - strings.ToLower(_MakeName[39:43]): 14, - _MakeName[43:46]: 16, - strings.ToLower(_MakeName[43:46]): 16, - _MakeName[46:59]: 18, - strings.ToLower(_MakeName[46:59]): 18, - _MakeName[59:69]: 20, - strings.ToLower(_MakeName[59:69]): 20, + _MakeName[0:6]: MakeToyota, + strings.ToLower(_MakeName[0:6]): MakeToyota, + _MakeName[6:11]: MakeChevy, + strings.ToLower(_MakeName[6:11]): MakeChevy, + _MakeName[11:15]: MakeFord, + strings.ToLower(_MakeName[11:15]): MakeFord, + _MakeName[15:20]: MakeTesla, + strings.ToLower(_MakeName[15:20]): MakeTesla, + _MakeName[20:27]: MakeHyundai, + strings.ToLower(_MakeName[20:27]): MakeHyundai, + _MakeName[27:33]: MakeNissan, + strings.ToLower(_MakeName[27:33]): MakeNissan, + _MakeName[33:39]: MakeJaguar, + strings.ToLower(_MakeName[33:39]): MakeJaguar, + _MakeName[39:43]: MakeAudi, + strings.ToLower(_MakeName[39:43]): MakeAudi, + _MakeName[43:46]: MakeBMW, + strings.ToLower(_MakeName[43:46]): MakeBMW, + _MakeName[46:59]: MakeMercedesBenz, + strings.ToLower(_MakeName[46:59]): MakeMercedesBenz, + _MakeName[59:69]: MakeVolkswagon, + strings.ToLower(_MakeName[59:69]): MakeVolkswagon, } -// ParseMake attempts to convert a string to a Make +// ParseMake attempts to convert a string to a Make. func ParseMake(name string) (Make, error) { if x, ok := _MakeValue[name]; ok { return x, nil @@ -132,15 +164,15 @@ func ParseMake(name string) (Make, error) { if x, ok := _MakeValue[strings.ToLower(name)]; ok { return x, nil } - return Make(0), fmt.Errorf("%s is not a valid Make, try [%s]", name, strings.Join(_MakeNames, ", ")) + return Make(0), fmt.Errorf("%s is %w", name, ErrInvalidMake) } -// MarshalText implements the text marshaller method +// MarshalText implements the text marshaller method. func (x Make) MarshalText() ([]byte, error) { return []byte(x.String()), nil } -// UnmarshalText implements the text unmarshaller method +// UnmarshalText implements the text unmarshaller method. func (x *Make) UnmarshalText(text []byte) error { name := string(text) tmp, err := ParseMake(name) @@ -183,6 +215,8 @@ const ( NoZerosPpps ) +var ErrInvalidNoZeros = fmt.Errorf("not a valid NoZeros, try [%s]", strings.Join(_NoZerosNames, ", ")) + const _NoZerosName = "startmiddleendpsppsppps" var _NoZerosNames = []string{ @@ -201,13 +235,25 @@ func NoZerosNames() []string { return tmp } +// NoZerosValues returns a list of the values for NoZeros +func NoZerosValues() []NoZeros { + return []NoZeros{ + NoZerosStart, + NoZerosMiddle, + NoZerosEnd, + NoZerosPs, + NoZerosPps, + NoZerosPpps, + } +} + var _NoZerosMap = map[NoZeros]string{ - 20: _NoZerosName[0:5], - 21: _NoZerosName[5:11], - 22: _NoZerosName[11:14], - 23: _NoZerosName[14:16], - 24: _NoZerosName[16:19], - 25: _NoZerosName[19:23], + NoZerosStart: _NoZerosName[0:5], + NoZerosMiddle: _NoZerosName[5:11], + NoZerosEnd: _NoZerosName[11:14], + NoZerosPs: _NoZerosName[14:16], + NoZerosPps: _NoZerosName[16:19], + NoZerosPpps: _NoZerosName[19:23], } // String implements the Stringer interface. @@ -218,22 +264,29 @@ func (x NoZeros) String() string { return fmt.Sprintf("NoZeros(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x NoZeros) IsValid() bool { + _, ok := _NoZerosMap[x] + return ok +} + var _NoZerosValue = map[string]NoZeros{ - _NoZerosName[0:5]: 20, - strings.ToLower(_NoZerosName[0:5]): 20, - _NoZerosName[5:11]: 21, - strings.ToLower(_NoZerosName[5:11]): 21, - _NoZerosName[11:14]: 22, - strings.ToLower(_NoZerosName[11:14]): 22, - _NoZerosName[14:16]: 23, - strings.ToLower(_NoZerosName[14:16]): 23, - _NoZerosName[16:19]: 24, - strings.ToLower(_NoZerosName[16:19]): 24, - _NoZerosName[19:23]: 25, - strings.ToLower(_NoZerosName[19:23]): 25, + _NoZerosName[0:5]: NoZerosStart, + strings.ToLower(_NoZerosName[0:5]): NoZerosStart, + _NoZerosName[5:11]: NoZerosMiddle, + strings.ToLower(_NoZerosName[5:11]): NoZerosMiddle, + _NoZerosName[11:14]: NoZerosEnd, + strings.ToLower(_NoZerosName[11:14]): NoZerosEnd, + _NoZerosName[14:16]: NoZerosPs, + strings.ToLower(_NoZerosName[14:16]): NoZerosPs, + _NoZerosName[16:19]: NoZerosPps, + strings.ToLower(_NoZerosName[16:19]): NoZerosPps, + _NoZerosName[19:23]: NoZerosPpps, + strings.ToLower(_NoZerosName[19:23]): NoZerosPpps, } -// ParseNoZeros attempts to convert a string to a NoZeros +// ParseNoZeros attempts to convert a string to a NoZeros. func ParseNoZeros(name string) (NoZeros, error) { if x, ok := _NoZerosValue[name]; ok { return x, nil @@ -242,15 +295,15 @@ func ParseNoZeros(name string) (NoZeros, error) { if x, ok := _NoZerosValue[strings.ToLower(name)]; ok { return x, nil } - return NoZeros(0), fmt.Errorf("%s is not a valid NoZeros, try [%s]", name, strings.Join(_NoZerosNames, ", ")) + return NoZeros(0), fmt.Errorf("%s is %w", name, ErrInvalidNoZeros) } -// MarshalText implements the text marshaller method +// MarshalText implements the text marshaller method. func (x NoZeros) MarshalText() ([]byte, error) { return []byte(x.String()), nil } -// UnmarshalText implements the text unmarshaller method +// UnmarshalText implements the text unmarshaller method. func (x *NoZeros) UnmarshalText(text []byte) error { name := string(text) tmp, err := ParseNoZeros(name) diff --git a/example/example_test.go b/example/example_test.go index 2e3d7e19..b9f22bbf 100644 --- a/example/example_test.go +++ b/example/example_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( @@ -195,7 +198,6 @@ func TestNoZeroValues(t *testing.T) { err = json.Unmarshal([]byte(`{"nz":"pppps"}`), &val) assert.EqualError(tt, err, "pppps is not a valid NoZeros, try [start, middle, end, ps, pps, ppps]") - }) for _, name := range NoZerosNames() { @@ -215,14 +217,11 @@ func TestNoZeroValues(t *testing.T) { require.Equal(tt, nz.Type(), "NoZeros") require.Equal(tt, NoZeros(0), nz.Get(), "Unset value should be default") require.NoError(tt, nz.Set(name), "failed setting flag value") - }) - } } func BenchmarkMakeParse(b *testing.B) { - knownItems := map[string]struct { input string output Make @@ -272,5 +271,4 @@ func BenchmarkMakeParse(b *testing.B) { } }) } - } diff --git a/example/force_lower.go b/example/force_lower.go new file mode 100644 index 00000000..dff681a2 --- /dev/null +++ b/example/force_lower.go @@ -0,0 +1,9 @@ +//go:generate ../bin/go-enum --forcelower -b example + +package example + +// ENUM( +// DataSwap, +// BootNode, +// ) +type ForceLowerType int diff --git a/example/force_lower_enum.go b/example/force_lower_enum.go new file mode 100644 index 00000000..8cbcf127 --- /dev/null +++ b/example/force_lower_enum.go @@ -0,0 +1,59 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "errors" + "fmt" +) + +const ( + // ForceLowerTypeDataSwap is a ForceLowerType of type DataSwap. + ForceLowerTypeDataSwap ForceLowerType = iota + // ForceLowerTypeBootNode is a ForceLowerType of type BootNode. + ForceLowerTypeBootNode +) + +var ErrInvalidForceLowerType = errors.New("not a valid ForceLowerType") + +const _ForceLowerTypeName = "dataswapbootnode" + +var _ForceLowerTypeMap = map[ForceLowerType]string{ + ForceLowerTypeDataSwap: _ForceLowerTypeName[0:8], + ForceLowerTypeBootNode: _ForceLowerTypeName[8:16], +} + +// String implements the Stringer interface. +func (x ForceLowerType) String() string { + if str, ok := _ForceLowerTypeMap[x]; ok { + return str + } + return fmt.Sprintf("ForceLowerType(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x ForceLowerType) IsValid() bool { + _, ok := _ForceLowerTypeMap[x] + return ok +} + +var _ForceLowerTypeValue = map[string]ForceLowerType{ + _ForceLowerTypeName[0:8]: ForceLowerTypeDataSwap, + _ForceLowerTypeName[8:16]: ForceLowerTypeBootNode, +} + +// ParseForceLowerType attempts to convert a string to a ForceLowerType. +func ParseForceLowerType(name string) (ForceLowerType, error) { + if x, ok := _ForceLowerTypeValue[name]; ok { + return x, nil + } + return ForceLowerType(0), fmt.Errorf("%s is %w", name, ErrInvalidForceLowerType) +} diff --git a/example/force_lower_test.go b/example/force_lower_test.go new file mode 100644 index 00000000..5fa32e27 --- /dev/null +++ b/example/force_lower_test.go @@ -0,0 +1,42 @@ +//go:build example +// +build example + +package example + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestForceLowerString(t *testing.T) { + tests := map[string]struct { + input string + output ForceLowerType + }{ + "dataswap": { + input: `dataswap`, + output: ForceLowerTypeDataSwap, + }, + "bootnode": { + input: `bootnode`, + output: ForceLowerTypeBootNode, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + output, err := ParseForceLowerType(tc.input) + assert.NoError(t, err) + assert.Equal(t, tc.output, output) + + assert.Equal(t, tc.input, output.String()) + }) + } + + t.Run("failures", func(t *testing.T) { + assert.Equal(t, "ForceLowerType(99)", ForceLowerType(99).String()) + _, err := ParseForceLowerType("-1") + assert.Error(t, err) + }) +} diff --git a/example/force_upper.go b/example/force_upper.go new file mode 100644 index 00000000..38e5ac3c --- /dev/null +++ b/example/force_upper.go @@ -0,0 +1,9 @@ +//go:generate ../bin/go-enum --forceupper -b example + +package example + +// ENUM( +// DataSwap, +// BootNode, +// ) +type ForceUpperType int diff --git a/example/force_upper_enum.go b/example/force_upper_enum.go new file mode 100644 index 00000000..44cd8928 --- /dev/null +++ b/example/force_upper_enum.go @@ -0,0 +1,59 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "errors" + "fmt" +) + +const ( + // ForceUpperTypeDataSwap is a ForceUpperType of type DataSwap. + ForceUpperTypeDataSwap ForceUpperType = iota + // ForceUpperTypeBootNode is a ForceUpperType of type BootNode. + ForceUpperTypeBootNode +) + +var ErrInvalidForceUpperType = errors.New("not a valid ForceUpperType") + +const _ForceUpperTypeName = "DATASWAPBOOTNODE" + +var _ForceUpperTypeMap = map[ForceUpperType]string{ + ForceUpperTypeDataSwap: _ForceUpperTypeName[0:8], + ForceUpperTypeBootNode: _ForceUpperTypeName[8:16], +} + +// String implements the Stringer interface. +func (x ForceUpperType) String() string { + if str, ok := _ForceUpperTypeMap[x]; ok { + return str + } + return fmt.Sprintf("ForceUpperType(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x ForceUpperType) IsValid() bool { + _, ok := _ForceUpperTypeMap[x] + return ok +} + +var _ForceUpperTypeValue = map[string]ForceUpperType{ + _ForceUpperTypeName[0:8]: ForceUpperTypeDataSwap, + _ForceUpperTypeName[8:16]: ForceUpperTypeBootNode, +} + +// ParseForceUpperType attempts to convert a string to a ForceUpperType. +func ParseForceUpperType(name string) (ForceUpperType, error) { + if x, ok := _ForceUpperTypeValue[name]; ok { + return x, nil + } + return ForceUpperType(0), fmt.Errorf("%s is %w", name, ErrInvalidForceUpperType) +} diff --git a/example/force_upper_test.go b/example/force_upper_test.go new file mode 100644 index 00000000..6bd6bbcd --- /dev/null +++ b/example/force_upper_test.go @@ -0,0 +1,42 @@ +//go:build example +// +build example + +package example + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestForceUpperString(t *testing.T) { + tests := map[string]struct { + input string + output ForceUpperType + }{ + "dataswap": { + input: `DATASWAP`, + output: ForceUpperTypeDataSwap, + }, + "bootnode": { + input: `BOOTNODE`, + output: ForceUpperTypeBootNode, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + output, err := ParseForceUpperType(tc.input) + assert.NoError(t, err) + assert.Equal(t, tc.output, output) + + assert.Equal(t, tc.input, output.String()) + }) + } + + t.Run("failures", func(t *testing.T) { + assert.Equal(t, "ForceUpperType(99)", ForceUpperType(99).String()) + _, err := ParseForceUpperType("-1") + assert.Error(t, err) + }) +} diff --git a/example/globs/gen.go b/example/globs/gen.go index f31bb06c..86ca94b5 100644 --- a/example/globs/gen.go +++ b/example/globs/gen.go @@ -1,3 +1,6 @@ -//go:generate ../../bin/go-enum -f=*.go +//go:build example +// +build example + +//go:generate ../../bin/go-enum -f=*.go -b example package globs diff --git a/example/globs/letter.go b/example/globs/letter.go index 016b45a7..1dcef51e 100644 --- a/example/globs/letter.go +++ b/example/globs/letter.go @@ -1,8 +1,14 @@ +//go:build example +// +build example + package globs -/** +/* +* ENUM( + a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z + ) */ type Letter int diff --git a/example/globs/letter_enum.go b/example/globs/letter_enum.go index 62212c5a..22a5678b 100644 --- a/example/globs/letter_enum.go +++ b/example/globs/letter_enum.go @@ -1,9 +1,16 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package globs import ( + "errors" "fmt" ) @@ -62,35 +69,37 @@ const ( LetterZ ) +var ErrInvalidLetter = errors.New("not a valid Letter") + const _LetterName = "abcdefghijklmnopqrstuvwxyz" var _LetterMap = map[Letter]string{ - 0: _LetterName[0:1], - 1: _LetterName[1:2], - 2: _LetterName[2:3], - 3: _LetterName[3:4], - 4: _LetterName[4:5], - 5: _LetterName[5:6], - 6: _LetterName[6:7], - 7: _LetterName[7:8], - 8: _LetterName[8:9], - 9: _LetterName[9:10], - 10: _LetterName[10:11], - 11: _LetterName[11:12], - 12: _LetterName[12:13], - 13: _LetterName[13:14], - 14: _LetterName[14:15], - 15: _LetterName[15:16], - 16: _LetterName[16:17], - 17: _LetterName[17:18], - 18: _LetterName[18:19], - 19: _LetterName[19:20], - 20: _LetterName[20:21], - 21: _LetterName[21:22], - 22: _LetterName[22:23], - 23: _LetterName[23:24], - 24: _LetterName[24:25], - 25: _LetterName[25:26], + LetterA: _LetterName[0:1], + LetterB: _LetterName[1:2], + LetterC: _LetterName[2:3], + LetterD: _LetterName[3:4], + LetterE: _LetterName[4:5], + LetterF: _LetterName[5:6], + LetterG: _LetterName[6:7], + LetterH: _LetterName[7:8], + LetterI: _LetterName[8:9], + LetterJ: _LetterName[9:10], + LetterK: _LetterName[10:11], + LetterL: _LetterName[11:12], + LetterM: _LetterName[12:13], + LetterN: _LetterName[13:14], + LetterO: _LetterName[14:15], + LetterP: _LetterName[15:16], + LetterQ: _LetterName[16:17], + LetterR: _LetterName[17:18], + LetterS: _LetterName[18:19], + LetterT: _LetterName[19:20], + LetterU: _LetterName[20:21], + LetterV: _LetterName[21:22], + LetterW: _LetterName[22:23], + LetterX: _LetterName[23:24], + LetterY: _LetterName[24:25], + LetterZ: _LetterName[25:26], } // String implements the Stringer interface. @@ -101,39 +110,46 @@ func (x Letter) String() string { return fmt.Sprintf("Letter(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Letter) IsValid() bool { + _, ok := _LetterMap[x] + return ok +} + var _LetterValue = map[string]Letter{ - _LetterName[0:1]: 0, - _LetterName[1:2]: 1, - _LetterName[2:3]: 2, - _LetterName[3:4]: 3, - _LetterName[4:5]: 4, - _LetterName[5:6]: 5, - _LetterName[6:7]: 6, - _LetterName[7:8]: 7, - _LetterName[8:9]: 8, - _LetterName[9:10]: 9, - _LetterName[10:11]: 10, - _LetterName[11:12]: 11, - _LetterName[12:13]: 12, - _LetterName[13:14]: 13, - _LetterName[14:15]: 14, - _LetterName[15:16]: 15, - _LetterName[16:17]: 16, - _LetterName[17:18]: 17, - _LetterName[18:19]: 18, - _LetterName[19:20]: 19, - _LetterName[20:21]: 20, - _LetterName[21:22]: 21, - _LetterName[22:23]: 22, - _LetterName[23:24]: 23, - _LetterName[24:25]: 24, - _LetterName[25:26]: 25, + _LetterName[0:1]: LetterA, + _LetterName[1:2]: LetterB, + _LetterName[2:3]: LetterC, + _LetterName[3:4]: LetterD, + _LetterName[4:5]: LetterE, + _LetterName[5:6]: LetterF, + _LetterName[6:7]: LetterG, + _LetterName[7:8]: LetterH, + _LetterName[8:9]: LetterI, + _LetterName[9:10]: LetterJ, + _LetterName[10:11]: LetterK, + _LetterName[11:12]: LetterL, + _LetterName[12:13]: LetterM, + _LetterName[13:14]: LetterN, + _LetterName[14:15]: LetterO, + _LetterName[15:16]: LetterP, + _LetterName[16:17]: LetterQ, + _LetterName[17:18]: LetterR, + _LetterName[18:19]: LetterS, + _LetterName[19:20]: LetterT, + _LetterName[20:21]: LetterU, + _LetterName[21:22]: LetterV, + _LetterName[22:23]: LetterW, + _LetterName[23:24]: LetterX, + _LetterName[24:25]: LetterY, + _LetterName[25:26]: LetterZ, } -// ParseLetter attempts to convert a string to a Letter +// ParseLetter attempts to convert a string to a Letter. func ParseLetter(name string) (Letter, error) { if x, ok := _LetterValue[name]; ok { return x, nil } - return Letter(0), fmt.Errorf("%s is not a valid Letter", name) + return Letter(0), fmt.Errorf("%s is %w", name, ErrInvalidLetter) } diff --git a/example/globs/number.go b/example/globs/number.go index 5641814a..211c255c 100644 --- a/example/globs/number.go +++ b/example/globs/number.go @@ -1,8 +1,14 @@ +//go:build example +// +build example + package globs -/** +/* +* ENUM( + 0,1,2,3,4,5,6,7,8,9 + ) */ type Number int diff --git a/example/globs/number_enum.go b/example/globs/number_enum.go index 05472e72..83b6657b 100644 --- a/example/globs/number_enum.go +++ b/example/globs/number_enum.go @@ -1,9 +1,16 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package globs import ( + "errors" "fmt" ) @@ -30,19 +37,21 @@ const ( Number9 ) +var ErrInvalidNumber = errors.New("not a valid Number") + const _NumberName = "0123456789" var _NumberMap = map[Number]string{ - 0: _NumberName[0:1], - 1: _NumberName[1:2], - 2: _NumberName[2:3], - 3: _NumberName[3:4], - 4: _NumberName[4:5], - 5: _NumberName[5:6], - 6: _NumberName[6:7], - 7: _NumberName[7:8], - 8: _NumberName[8:9], - 9: _NumberName[9:10], + Number0: _NumberName[0:1], + Number1: _NumberName[1:2], + Number2: _NumberName[2:3], + Number3: _NumberName[3:4], + Number4: _NumberName[4:5], + Number5: _NumberName[5:6], + Number6: _NumberName[6:7], + Number7: _NumberName[7:8], + Number8: _NumberName[8:9], + Number9: _NumberName[9:10], } // String implements the Stringer interface. @@ -53,23 +62,30 @@ func (x Number) String() string { return fmt.Sprintf("Number(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Number) IsValid() bool { + _, ok := _NumberMap[x] + return ok +} + var _NumberValue = map[string]Number{ - _NumberName[0:1]: 0, - _NumberName[1:2]: 1, - _NumberName[2:3]: 2, - _NumberName[3:4]: 3, - _NumberName[4:5]: 4, - _NumberName[5:6]: 5, - _NumberName[6:7]: 6, - _NumberName[7:8]: 7, - _NumberName[8:9]: 8, - _NumberName[9:10]: 9, + _NumberName[0:1]: Number0, + _NumberName[1:2]: Number1, + _NumberName[2:3]: Number2, + _NumberName[3:4]: Number3, + _NumberName[4:5]: Number4, + _NumberName[5:6]: Number5, + _NumberName[6:7]: Number6, + _NumberName[7:8]: Number7, + _NumberName[8:9]: Number8, + _NumberName[9:10]: Number9, } -// ParseNumber attempts to convert a string to a Number +// ParseNumber attempts to convert a string to a Number. func ParseNumber(name string) (Number, error) { if x, ok := _NumberValue[name]; ok { return x, nil } - return Number(0), fmt.Errorf("%s is not a valid Number", name) + return Number(0), fmt.Errorf("%s is %w", name, ErrInvalidNumber) } diff --git a/example/go_enum_enum_test.go b/example/go_enum_enum_test.go new file mode 100644 index 00000000..4ac5436e --- /dev/null +++ b/example/go_enum_enum_test.go @@ -0,0 +1,46 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +package example + +import ( + "errors" + "fmt" +) + +const ( + // TestOnlyEnumABCDX is a TestOnlyEnum of type ABCD (x). + TestOnlyEnumABCDX TestOnlyEnum = "ABCD (x)" + // TestOnlyEnumEFGHY is a TestOnlyEnum of type EFGH (y). + TestOnlyEnumEFGHY TestOnlyEnum = "EFGH (y)" +) + +var ErrInvalidTestOnlyEnum = errors.New("not a valid TestOnlyEnum") + +// String implements the Stringer interface. +func (x TestOnlyEnum) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x TestOnlyEnum) IsValid() bool { + _, err := ParseTestOnlyEnum(string(x)) + return err == nil +} + +var _TestOnlyEnumValue = map[string]TestOnlyEnum{ + "ABCD (x)": TestOnlyEnumABCDX, + "EFGH (y)": TestOnlyEnumEFGHY, +} + +// ParseTestOnlyEnum attempts to convert a string to a TestOnlyEnum. +func ParseTestOnlyEnum(name string) (TestOnlyEnum, error) { + if x, ok := _TestOnlyEnumValue[name]; ok { + return x, nil + } + return TestOnlyEnum(""), fmt.Errorf("%s is %w", name, ErrInvalidTestOnlyEnum) +} diff --git a/example/go_enum_test.go b/example/go_enum_test.go new file mode 100644 index 00000000..4f33ae80 --- /dev/null +++ b/example/go_enum_test.go @@ -0,0 +1,12 @@ +//go:generate ../bin/go-enum +package example + +/* +ENUM( + + ABCD (x), + EFGH (y), + +) +*/ +type TestOnlyEnum string diff --git a/example/negative.go b/example/negative.go new file mode 100644 index 00000000..a33013c2 --- /dev/null +++ b/example/negative.go @@ -0,0 +1,22 @@ +//go:generate ../bin/go-enum --nocase -b example + +package example + +/* +ENUM( +Unknown = -1, +Good, +Bad +). +*/ +type Status int + +/* +ENUM( +Unknown = -5, +Good, +Bad, +Ugly +). +*/ +type AllNegative int diff --git a/example/negative_enum.go b/example/negative_enum.go new file mode 100644 index 00000000..a3d458b9 --- /dev/null +++ b/example/negative_enum.go @@ -0,0 +1,131 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "errors" + "fmt" + "strings" +) + +const ( + // AllNegativeUnknown is a AllNegative of type Unknown. + AllNegativeUnknown AllNegative = iota + -5 + // AllNegativeGood is a AllNegative of type Good. + AllNegativeGood + // AllNegativeBad is a AllNegative of type Bad. + AllNegativeBad + // AllNegativeUgly is a AllNegative of type Ugly. + AllNegativeUgly +) + +var ErrInvalidAllNegative = errors.New("not a valid AllNegative") + +const _AllNegativeName = "UnknownGoodBadUgly" + +var _AllNegativeMap = map[AllNegative]string{ + AllNegativeUnknown: _AllNegativeName[0:7], + AllNegativeGood: _AllNegativeName[7:11], + AllNegativeBad: _AllNegativeName[11:14], + AllNegativeUgly: _AllNegativeName[14:18], +} + +// String implements the Stringer interface. +func (x AllNegative) String() string { + if str, ok := _AllNegativeMap[x]; ok { + return str + } + return fmt.Sprintf("AllNegative(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x AllNegative) IsValid() bool { + _, ok := _AllNegativeMap[x] + return ok +} + +var _AllNegativeValue = map[string]AllNegative{ + _AllNegativeName[0:7]: AllNegativeUnknown, + strings.ToLower(_AllNegativeName[0:7]): AllNegativeUnknown, + _AllNegativeName[7:11]: AllNegativeGood, + strings.ToLower(_AllNegativeName[7:11]): AllNegativeGood, + _AllNegativeName[11:14]: AllNegativeBad, + strings.ToLower(_AllNegativeName[11:14]): AllNegativeBad, + _AllNegativeName[14:18]: AllNegativeUgly, + strings.ToLower(_AllNegativeName[14:18]): AllNegativeUgly, +} + +// ParseAllNegative attempts to convert a string to a AllNegative. +func ParseAllNegative(name string) (AllNegative, error) { + if x, ok := _AllNegativeValue[name]; ok { + return x, nil + } + // Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to. + if x, ok := _AllNegativeValue[strings.ToLower(name)]; ok { + return x, nil + } + return AllNegative(0), fmt.Errorf("%s is %w", name, ErrInvalidAllNegative) +} + +const ( + // StatusUnknown is a Status of type Unknown. + StatusUnknown Status = iota + -1 + // StatusGood is a Status of type Good. + StatusGood + // StatusBad is a Status of type Bad. + StatusBad +) + +var ErrInvalidStatus = errors.New("not a valid Status") + +const _StatusName = "UnknownGoodBad" + +var _StatusMap = map[Status]string{ + StatusUnknown: _StatusName[0:7], + StatusGood: _StatusName[7:11], + StatusBad: _StatusName[11:14], +} + +// String implements the Stringer interface. +func (x Status) String() string { + if str, ok := _StatusMap[x]; ok { + return str + } + return fmt.Sprintf("Status(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Status) IsValid() bool { + _, ok := _StatusMap[x] + return ok +} + +var _StatusValue = map[string]Status{ + _StatusName[0:7]: StatusUnknown, + strings.ToLower(_StatusName[0:7]): StatusUnknown, + _StatusName[7:11]: StatusGood, + strings.ToLower(_StatusName[7:11]): StatusGood, + _StatusName[11:14]: StatusBad, + strings.ToLower(_StatusName[11:14]): StatusBad, +} + +// ParseStatus attempts to convert a string to a Status. +func ParseStatus(name string) (Status, error) { + if x, ok := _StatusValue[name]; ok { + return x, nil + } + // Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to. + if x, ok := _StatusValue[strings.ToLower(name)]; ok { + return x, nil + } + return Status(0), fmt.Errorf("%s is %w", name, ErrInvalidStatus) +} diff --git a/example/negative_test.go b/example/negative_test.go new file mode 100644 index 00000000..34c3edce --- /dev/null +++ b/example/negative_test.go @@ -0,0 +1,100 @@ +//go:build example +// +build example + +package example + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestStatusString(t *testing.T) { + tests := map[string]struct { + input string + output Status + }{ + "bad": { + input: `Bad`, + output: StatusBad, + }, + "unknown": { + input: `Unknown`, + output: StatusUnknown, + }, + "good": { + input: `Good`, + output: StatusGood, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + output, err := ParseStatus(tc.input) + assert.NoError(t, err) + assert.Equal(t, tc.output, output) + + assert.Equal(t, tc.input, output.String()) + }) + } + + t.Run("failures", func(t *testing.T) { + assert.Equal(t, "Status(99)", Status(99).String()) + failedStatus, err := ParseStatus("") + assert.Error(t, err) + + assert.Equal(t, Status(0), failedStatus) + t.Run("cased", func(t *testing.T) { + actual, err := ParseStatus("BAD") + assert.NoError(t, err) + assert.Equal(t, StatusBad, actual) + }) + }) +} + +func TestNegativeString(t *testing.T) { + tests := map[string]struct { + input string + output AllNegative + }{ + "unknown": { + input: `Unknown`, + output: AllNegativeUnknown, + }, + "good": { + input: `Good`, + output: AllNegativeGood, + }, + "bad": { + input: `Bad`, + output: AllNegativeBad, + }, + "ugly": { + input: `Ugly`, + output: AllNegativeUgly, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + output, err := ParseAllNegative(tc.input) + assert.NoError(t, err) + assert.Equal(t, tc.output, output) + + assert.Equal(t, tc.input, output.String()) + }) + } + + t.Run("failures", func(t *testing.T) { + assert.Equal(t, "AllNegative(99)", AllNegative(99).String()) + allN, err := ParseAllNegative("") + assert.Error(t, err) + + assert.Equal(t, AllNegative(0), allN) + }) + t.Run("cased", func(t *testing.T) { + actual, err := ParseAllNegative("UGLY") + assert.NoError(t, err) + assert.Equal(t, AllNegativeUgly, actual) + }) +} diff --git a/example/replace_prefix.go b/example/replace_prefix.go new file mode 100644 index 00000000..25f6ad92 --- /dev/null +++ b/example/replace_prefix.go @@ -0,0 +1,10 @@ +//go:generate ../bin/go-enum --marshal --prefix=AcmeInc_ --noprefix --nocamel --names -b example + +package example + +// Shops ENUM( +// SOME_PLACE_AWESOME, +// SomewhereElse, +// LocationUnknown +// ) +type Shop string diff --git a/example/replace_prefix_enum.go b/example/replace_prefix_enum.go new file mode 100644 index 00000000..3ae36f33 --- /dev/null +++ b/example/replace_prefix_enum.go @@ -0,0 +1,80 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "fmt" + "strings" +) + +const ( + // AcmeInc_SOME_PLACE_AWESOME is a Shop of type SOME_PLACE_AWESOME. + AcmeInc_SOME_PLACE_AWESOME Shop = "SOME_PLACE_AWESOME" + // AcmeInc_SomewhereElse is a Shop of type SomewhereElse. + AcmeInc_SomewhereElse Shop = "SomewhereElse" + // AcmeInc_LocationUnknown is a Shop of type LocationUnknown. + AcmeInc_LocationUnknown Shop = "LocationUnknown" +) + +var ErrInvalidShop = fmt.Errorf("not a valid Shop, try [%s]", strings.Join(_ShopNames, ", ")) + +var _ShopNames = []string{ + string(AcmeInc_SOME_PLACE_AWESOME), + string(AcmeInc_SomewhereElse), + string(AcmeInc_LocationUnknown), +} + +// ShopNames returns a list of possible string values of Shop. +func ShopNames() []string { + tmp := make([]string, len(_ShopNames)) + copy(tmp, _ShopNames) + return tmp +} + +// String implements the Stringer interface. +func (x Shop) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Shop) IsValid() bool { + _, err := ParseShop(string(x)) + return err == nil +} + +var _ShopValue = map[string]Shop{ + "SOME_PLACE_AWESOME": AcmeInc_SOME_PLACE_AWESOME, + "SomewhereElse": AcmeInc_SomewhereElse, + "LocationUnknown": AcmeInc_LocationUnknown, +} + +// ParseShop attempts to convert a string to a Shop. +func ParseShop(name string) (Shop, error) { + if x, ok := _ShopValue[name]; ok { + return x, nil + } + return Shop(""), fmt.Errorf("%s is %w", name, ErrInvalidShop) +} + +// MarshalText implements the text marshaller method. +func (x Shop) MarshalText() ([]byte, error) { + return []byte(string(x)), nil +} + +// UnmarshalText implements the text unmarshaller method. +func (x *Shop) UnmarshalText(text []byte) error { + tmp, err := ParseShop(string(text)) + if err != nil { + return err + } + *x = tmp + return nil +} diff --git a/example/replace_prefix_int.go b/example/replace_prefix_int.go new file mode 100644 index 00000000..ef6f26af --- /dev/null +++ b/example/replace_prefix_int.go @@ -0,0 +1,10 @@ +//go:generate ../bin/go-enum --marshal --prefix=AcmeInt_ --noprefix --nocamel --names -b example + +package example + +// Shops ENUM( +// SOME_PLACE_AWESOME, +// SomewhereElse, +// LocationUnknown +// ) +type IntShop int diff --git a/example/replace_prefix_int_enum.go b/example/replace_prefix_int_enum.go new file mode 100644 index 00000000..facf966d --- /dev/null +++ b/example/replace_prefix_int_enum.go @@ -0,0 +1,92 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "fmt" + "strings" +) + +const ( + // AcmeInt_SOME_PLACE_AWESOME is a IntShop of type SOME_PLACE_AWESOME. + AcmeInt_SOME_PLACE_AWESOME IntShop = iota + // AcmeInt_SomewhereElse is a IntShop of type SomewhereElse. + AcmeInt_SomewhereElse + // AcmeInt_LocationUnknown is a IntShop of type LocationUnknown. + AcmeInt_LocationUnknown +) + +var ErrInvalidIntShop = fmt.Errorf("not a valid IntShop, try [%s]", strings.Join(_IntShopNames, ", ")) + +const _IntShopName = "SOME_PLACE_AWESOMESomewhereElseLocationUnknown" + +var _IntShopNames = []string{ + _IntShopName[0:18], + _IntShopName[18:31], + _IntShopName[31:46], +} + +// IntShopNames returns a list of possible string values of IntShop. +func IntShopNames() []string { + tmp := make([]string, len(_IntShopNames)) + copy(tmp, _IntShopNames) + return tmp +} + +var _IntShopMap = map[IntShop]string{ + AcmeInt_SOME_PLACE_AWESOME: _IntShopName[0:18], + AcmeInt_SomewhereElse: _IntShopName[18:31], + AcmeInt_LocationUnknown: _IntShopName[31:46], +} + +// String implements the Stringer interface. +func (x IntShop) String() string { + if str, ok := _IntShopMap[x]; ok { + return str + } + return fmt.Sprintf("IntShop(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x IntShop) IsValid() bool { + _, ok := _IntShopMap[x] + return ok +} + +var _IntShopValue = map[string]IntShop{ + _IntShopName[0:18]: AcmeInt_SOME_PLACE_AWESOME, + _IntShopName[18:31]: AcmeInt_SomewhereElse, + _IntShopName[31:46]: AcmeInt_LocationUnknown, +} + +// ParseIntShop attempts to convert a string to a IntShop. +func ParseIntShop(name string) (IntShop, error) { + if x, ok := _IntShopValue[name]; ok { + return x, nil + } + return IntShop(0), fmt.Errorf("%s is %w", name, ErrInvalidIntShop) +} + +// MarshalText implements the text marshaller method. +func (x IntShop) MarshalText() ([]byte, error) { + return []byte(x.String()), nil +} + +// UnmarshalText implements the text unmarshaller method. +func (x *IntShop) UnmarshalText(text []byte) error { + name := string(text) + tmp, err := ParseIntShop(name) + if err != nil { + return err + } + *x = tmp + return nil +} diff --git a/example/sql.go b/example/sql.go index 182d5112..02bcfec4 100644 --- a/example/sql.go +++ b/example/sql.go @@ -1,4 +1,4 @@ -//go:generate ../bin/go-enum -f=$GOFILE --sql --sqlnullstr --sqlnullint --ptr --marshal +//go:generate ../bin/go-enum --sql --sqlnullstr --sqlnullint --ptr --marshal --nocomments -b example package example diff --git a/example/sql_1_11_test.go b/example/sql_1_11_test.go index 5d519292..befdf149 100644 --- a/example/sql_1_11_test.go +++ b/example/sql_1_11_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + //go:generate ../bin/mockgen -destination sql_mock_test.go -package example database/sql/driver Conn,Driver,Stmt,Result,Rows /* @@ -47,7 +50,6 @@ func MatchesValues(vals ...driver.Value) *DriverValueMatcher { // Matches returns whether x is a match. func (d *DriverValueMatcher) Matches(x interface{}) bool { - switch values := x.(type) { case []driver.Value: if len(values) != len(d.values) { @@ -97,7 +99,6 @@ func WithMockSQL(t testing.TB) (*MockSQL, func()) { } func TestExampleSQL(t *testing.T) { - tests := map[string]struct { setupMock func(t testing.TB, mocks *MockSQL) tester func(t testing.TB, db *sql.DB) @@ -467,7 +468,6 @@ func TestExampleSQL(t *testing.T) { sql.Register("mock", driver) for name, tc := range tests { t.Run(name, func(t *testing.T) { - require.NotNil(t, tc.setupMock) require.NotNil(t, tc.tester) @@ -482,7 +482,6 @@ func TestExampleSQL(t *testing.T) { tc.setupMock(t, mocks) tc.tester(t, conn) - }) } } diff --git a/example/sql_enum.go b/example/sql_enum.go index 220189f5..11351d32 100644 --- a/example/sql_enum.go +++ b/example/sql_enum.go @@ -1,34 +1,38 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example import ( "database/sql/driver" - "encoding/json" + json "encoding/json" "errors" "fmt" "strconv" ) const ( - // ProjectStatusPending is a ProjectStatus of type Pending. ProjectStatusPending ProjectStatus = iota - // ProjectStatusInWork is a ProjectStatus of type InWork. ProjectStatusInWork - // ProjectStatusCompleted is a ProjectStatus of type Completed. ProjectStatusCompleted - // ProjectStatusRejected is a ProjectStatus of type Rejected. ProjectStatusRejected ) +var ErrInvalidProjectStatus = errors.New("not a valid ProjectStatus") + const _ProjectStatusName = "pendinginWorkcompletedrejected" var _ProjectStatusMap = map[ProjectStatus]string{ - 0: _ProjectStatusName[0:7], - 1: _ProjectStatusName[7:13], - 2: _ProjectStatusName[13:22], - 3: _ProjectStatusName[22:30], + ProjectStatusPending: _ProjectStatusName[0:7], + ProjectStatusInWork: _ProjectStatusName[7:13], + ProjectStatusCompleted: _ProjectStatusName[13:22], + ProjectStatusRejected: _ProjectStatusName[22:30], } // String implements the Stringer interface. @@ -39,31 +43,38 @@ func (x ProjectStatus) String() string { return fmt.Sprintf("ProjectStatus(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x ProjectStatus) IsValid() bool { + _, ok := _ProjectStatusMap[x] + return ok +} + var _ProjectStatusValue = map[string]ProjectStatus{ - _ProjectStatusName[0:7]: 0, - _ProjectStatusName[7:13]: 1, - _ProjectStatusName[13:22]: 2, - _ProjectStatusName[22:30]: 3, + _ProjectStatusName[0:7]: ProjectStatusPending, + _ProjectStatusName[7:13]: ProjectStatusInWork, + _ProjectStatusName[13:22]: ProjectStatusCompleted, + _ProjectStatusName[22:30]: ProjectStatusRejected, } -// ParseProjectStatus attempts to convert a string to a ProjectStatus +// ParseProjectStatus attempts to convert a string to a ProjectStatus. func ParseProjectStatus(name string) (ProjectStatus, error) { if x, ok := _ProjectStatusValue[name]; ok { return x, nil } - return ProjectStatus(0), fmt.Errorf("%s is not a valid ProjectStatus", name) + return ProjectStatus(0), fmt.Errorf("%s is %w", name, ErrInvalidProjectStatus) } func (x ProjectStatus) Ptr() *ProjectStatus { return &x } -// MarshalText implements the text marshaller method +// MarshalText implements the text marshaller method. func (x ProjectStatus) MarshalText() ([]byte, error) { return []byte(x.String()), nil } -// UnmarshalText implements the text unmarshaller method +// UnmarshalText implements the text unmarshaller method. func (x *ProjectStatus) UnmarshalText(text []byte) error { name := string(text) tmp, err := ParseProjectStatus(name) @@ -74,7 +85,7 @@ func (x *ProjectStatus) UnmarshalText(text []byte) error { return nil } -var _ProjectStatusErrNilPtr = errors.New("value pointer is nil") // one per type for package clashes +var errProjectStatusNilPtr = errors.New("value pointer is nil") // one per type for package clashes // Scan implements the Scanner interface. func (x *ProjectStatus) Scan(value interface{}) (err error) { @@ -110,7 +121,7 @@ func (x *ProjectStatus) Scan(value interface{}) (err error) { *x = ProjectStatus(v) case *ProjectStatus: if v == nil { - return _ProjectStatusErrNilPtr + return errProjectStatusNilPtr } *x = *v case uint: @@ -119,34 +130,34 @@ func (x *ProjectStatus) Scan(value interface{}) (err error) { *x = ProjectStatus(v) case *int: if v == nil { - return _ProjectStatusErrNilPtr + return errProjectStatusNilPtr } *x = ProjectStatus(*v) case *int64: if v == nil { - return _ProjectStatusErrNilPtr + return errProjectStatusNilPtr } *x = ProjectStatus(*v) case float64: // json marshals everything as a float64 if it's a number *x = ProjectStatus(v) case *float64: // json marshals everything as a float64 if it's a number if v == nil { - return _ProjectStatusErrNilPtr + return errProjectStatusNilPtr } *x = ProjectStatus(*v) case *uint: if v == nil { - return _ProjectStatusErrNilPtr + return errProjectStatusNilPtr } *x = ProjectStatus(*v) case *uint64: if v == nil { - return _ProjectStatusErrNilPtr + return errProjectStatusNilPtr } *x = ProjectStatus(*v) case *string: if v == nil { - return _ProjectStatusErrNilPtr + return errProjectStatusNilPtr } *x, err = ParseProjectStatus(*v) if err != nil { diff --git a/example/sql_int.go b/example/sql_int.go index 482a9a98..cc818458 100644 --- a/example/sql_int.go +++ b/example/sql_int.go @@ -1,4 +1,4 @@ -//go:generate ../bin/go-enum -f=$GOFILE --sqlnullint +//go:generate ../bin/go-enum --sqlnullint -b example package example diff --git a/example/sql_int_enum.go b/example/sql_int_enum.go index c874daf3..6a4695b4 100644 --- a/example/sql_int_enum.go +++ b/example/sql_int_enum.go @@ -1,5 +1,11 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example @@ -23,14 +29,16 @@ const ( ImageTypeGif ) +var ErrInvalidImageType = errors.New("not a valid ImageType") + const _ImageTypeName = "jpegjpgpngtiffgif" var _ImageTypeMap = map[ImageType]string{ - 0: _ImageTypeName[0:4], - 1: _ImageTypeName[4:7], - 2: _ImageTypeName[7:10], - 3: _ImageTypeName[10:14], - 4: _ImageTypeName[14:17], + ImageTypeJpeg: _ImageTypeName[0:4], + ImageTypeJpg: _ImageTypeName[4:7], + ImageTypePng: _ImageTypeName[7:10], + ImageTypeTiff: _ImageTypeName[10:14], + ImageTypeGif: _ImageTypeName[14:17], } // String implements the Stringer interface. @@ -41,23 +49,30 @@ func (x ImageType) String() string { return fmt.Sprintf("ImageType(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x ImageType) IsValid() bool { + _, ok := _ImageTypeMap[x] + return ok +} + var _ImageTypeValue = map[string]ImageType{ - _ImageTypeName[0:4]: 0, - _ImageTypeName[4:7]: 1, - _ImageTypeName[7:10]: 2, - _ImageTypeName[10:14]: 3, - _ImageTypeName[14:17]: 4, + _ImageTypeName[0:4]: ImageTypeJpeg, + _ImageTypeName[4:7]: ImageTypeJpg, + _ImageTypeName[7:10]: ImageTypePng, + _ImageTypeName[10:14]: ImageTypeTiff, + _ImageTypeName[14:17]: ImageTypeGif, } -// ParseImageType attempts to convert a string to a ImageType +// ParseImageType attempts to convert a string to a ImageType. func ParseImageType(name string) (ImageType, error) { if x, ok := _ImageTypeValue[name]; ok { return x, nil } - return ImageType(0), fmt.Errorf("%s is not a valid ImageType", name) + return ImageType(0), fmt.Errorf("%s is %w", name, ErrInvalidImageType) } -var _ImageTypeErrNilPtr = errors.New("value pointer is nil") // one per type for package clashes +var errImageTypeNilPtr = errors.New("value pointer is nil") // one per type for package clashes // Scan implements the Scanner interface. func (x *ImageType) Scan(value interface{}) (err error) { @@ -93,7 +108,7 @@ func (x *ImageType) Scan(value interface{}) (err error) { *x = ImageType(v) case *ImageType: if v == nil { - return _ImageTypeErrNilPtr + return errImageTypeNilPtr } *x = *v case uint: @@ -102,34 +117,34 @@ func (x *ImageType) Scan(value interface{}) (err error) { *x = ImageType(v) case *int: if v == nil { - return _ImageTypeErrNilPtr + return errImageTypeNilPtr } *x = ImageType(*v) case *int64: if v == nil { - return _ImageTypeErrNilPtr + return errImageTypeNilPtr } *x = ImageType(*v) case float64: // json marshals everything as a float64 if it's a number *x = ImageType(v) case *float64: // json marshals everything as a float64 if it's a number if v == nil { - return _ImageTypeErrNilPtr + return errImageTypeNilPtr } *x = ImageType(*v) case *uint: if v == nil { - return _ImageTypeErrNilPtr + return errImageTypeNilPtr } *x = ImageType(*v) case *uint64: if v == nil { - return _ImageTypeErrNilPtr + return errImageTypeNilPtr } *x = ImageType(*v) case *string: if v == nil { - return _ImageTypeErrNilPtr + return errImageTypeNilPtr } *x, err = ParseImageType(*v) if err != nil { diff --git a/example/sql_int_enum_test.go b/example/sql_int_enum_test.go index 6d0350b4..f388be92 100644 --- a/example/sql_int_enum_test.go +++ b/example/sql_int_enum_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( @@ -16,7 +19,6 @@ const ( ) func TestExampleSQLIntOnly(t *testing.T) { - tests := map[string]struct { setupMock func(t testing.TB, mocks *MockSQL) tester func(t testing.TB, db *sql.DB) @@ -332,7 +334,6 @@ func TestExampleSQLIntOnly(t *testing.T) { for name, tc := range tests { t.Run(name, func(t *testing.T) { - require.NotNil(t, tc.setupMock) require.NotNil(t, tc.tester) @@ -348,7 +349,6 @@ func TestExampleSQLIntOnly(t *testing.T) { tc.setupMock(t, mocks) tc.tester(t, conn) - }) } } @@ -369,7 +369,6 @@ func setImageType(db *sql.DB, state interface{}) error { } func TestSQLIntExtras(t *testing.T) { - assert.Equal(t, "ImageType(22)", ImageType(22).String(), "String value is not correct") _, err := ParseImageType(`NotAStatus`) @@ -475,8 +474,6 @@ func TestSQLIntExtras(t *testing.T) { t.Run(name, func(t *testing.T) { status := NewNullImageType(tc.input) assert.Equal(t, status, tc.result) - }) } - } diff --git a/example/sql_mock_test.go b/example/sql_mock_test.go index 6c0e8ec0..baa32a5e 100644 --- a/example/sql_mock_test.go +++ b/example/sql_mock_test.go @@ -6,34 +6,35 @@ package example import ( driver "database/sql/driver" - gomock "github.com/golang/mock/gomock" reflect "reflect" + + gomock "github.com/golang/mock/gomock" ) -// MockConn is a mock of Conn interface +// MockConn is a mock of Conn interface. type MockConn struct { ctrl *gomock.Controller recorder *MockConnMockRecorder } -// MockConnMockRecorder is the mock recorder for MockConn +// MockConnMockRecorder is the mock recorder for MockConn. type MockConnMockRecorder struct { mock *MockConn } -// NewMockConn creates a new mock instance +// NewMockConn creates a new mock instance. func NewMockConn(ctrl *gomock.Controller) *MockConn { mock := &MockConn{ctrl: ctrl} mock.recorder = &MockConnMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockConn) EXPECT() *MockConnMockRecorder { return m.recorder } -// Begin mocks base method +// Begin mocks base method. func (m *MockConn) Begin() (driver.Tx, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Begin") @@ -42,13 +43,13 @@ func (m *MockConn) Begin() (driver.Tx, error) { return ret0, ret1 } -// Begin indicates an expected call of Begin +// Begin indicates an expected call of Begin. func (mr *MockConnMockRecorder) Begin() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockConn)(nil).Begin)) } -// Close mocks base method +// Close mocks base method. func (m *MockConn) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -56,13 +57,13 @@ func (m *MockConn) Close() error { return ret0 } -// Close indicates an expected call of Close +// Close indicates an expected call of Close. func (mr *MockConnMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConn)(nil).Close)) } -// Prepare mocks base method +// Prepare mocks base method. func (m *MockConn) Prepare(arg0 string) (driver.Stmt, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Prepare", arg0) @@ -71,36 +72,36 @@ func (m *MockConn) Prepare(arg0 string) (driver.Stmt, error) { return ret0, ret1 } -// Prepare indicates an expected call of Prepare +// Prepare indicates an expected call of Prepare. func (mr *MockConnMockRecorder) Prepare(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockConn)(nil).Prepare), arg0) } -// MockDriver is a mock of Driver interface +// MockDriver is a mock of Driver interface. type MockDriver struct { ctrl *gomock.Controller recorder *MockDriverMockRecorder } -// MockDriverMockRecorder is the mock recorder for MockDriver +// MockDriverMockRecorder is the mock recorder for MockDriver. type MockDriverMockRecorder struct { mock *MockDriver } -// NewMockDriver creates a new mock instance +// NewMockDriver creates a new mock instance. func NewMockDriver(ctrl *gomock.Controller) *MockDriver { mock := &MockDriver{ctrl: ctrl} mock.recorder = &MockDriverMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockDriver) EXPECT() *MockDriverMockRecorder { return m.recorder } -// Open mocks base method +// Open mocks base method. func (m *MockDriver) Open(arg0 string) (driver.Conn, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Open", arg0) @@ -109,36 +110,36 @@ func (m *MockDriver) Open(arg0 string) (driver.Conn, error) { return ret0, ret1 } -// Open indicates an expected call of Open +// Open indicates an expected call of Open. func (mr *MockDriverMockRecorder) Open(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockDriver)(nil).Open), arg0) } -// MockStmt is a mock of Stmt interface +// MockStmt is a mock of Stmt interface. type MockStmt struct { ctrl *gomock.Controller recorder *MockStmtMockRecorder } -// MockStmtMockRecorder is the mock recorder for MockStmt +// MockStmtMockRecorder is the mock recorder for MockStmt. type MockStmtMockRecorder struct { mock *MockStmt } -// NewMockStmt creates a new mock instance +// NewMockStmt creates a new mock instance. func NewMockStmt(ctrl *gomock.Controller) *MockStmt { mock := &MockStmt{ctrl: ctrl} mock.recorder = &MockStmtMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockStmt) EXPECT() *MockStmtMockRecorder { return m.recorder } -// Close mocks base method +// Close mocks base method. func (m *MockStmt) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -146,13 +147,13 @@ func (m *MockStmt) Close() error { return ret0 } -// Close indicates an expected call of Close +// Close indicates an expected call of Close. func (mr *MockStmtMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStmt)(nil).Close)) } -// Exec mocks base method +// Exec mocks base method. func (m *MockStmt) Exec(arg0 []driver.Value) (driver.Result, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Exec", arg0) @@ -161,13 +162,13 @@ func (m *MockStmt) Exec(arg0 []driver.Value) (driver.Result, error) { return ret0, ret1 } -// Exec indicates an expected call of Exec +// Exec indicates an expected call of Exec. func (mr *MockStmtMockRecorder) Exec(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockStmt)(nil).Exec), arg0) } -// NumInput mocks base method +// NumInput mocks base method. func (m *MockStmt) NumInput() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NumInput") @@ -175,13 +176,13 @@ func (m *MockStmt) NumInput() int { return ret0 } -// NumInput indicates an expected call of NumInput +// NumInput indicates an expected call of NumInput. func (mr *MockStmtMockRecorder) NumInput() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumInput", reflect.TypeOf((*MockStmt)(nil).NumInput)) } -// Query mocks base method +// Query mocks base method. func (m *MockStmt) Query(arg0 []driver.Value) (driver.Rows, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", arg0) @@ -190,36 +191,36 @@ func (m *MockStmt) Query(arg0 []driver.Value) (driver.Rows, error) { return ret0, ret1 } -// Query indicates an expected call of Query +// Query indicates an expected call of Query. func (mr *MockStmtMockRecorder) Query(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockStmt)(nil).Query), arg0) } -// MockResult is a mock of Result interface +// MockResult is a mock of Result interface. type MockResult struct { ctrl *gomock.Controller recorder *MockResultMockRecorder } -// MockResultMockRecorder is the mock recorder for MockResult +// MockResultMockRecorder is the mock recorder for MockResult. type MockResultMockRecorder struct { mock *MockResult } -// NewMockResult creates a new mock instance +// NewMockResult creates a new mock instance. func NewMockResult(ctrl *gomock.Controller) *MockResult { mock := &MockResult{ctrl: ctrl} mock.recorder = &MockResultMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockResult) EXPECT() *MockResultMockRecorder { return m.recorder } -// LastInsertId mocks base method +// LastInsertId mocks base method. func (m *MockResult) LastInsertId() (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LastInsertId") @@ -228,13 +229,13 @@ func (m *MockResult) LastInsertId() (int64, error) { return ret0, ret1 } -// LastInsertId indicates an expected call of LastInsertId +// LastInsertId indicates an expected call of LastInsertId. func (mr *MockResultMockRecorder) LastInsertId() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastInsertId", reflect.TypeOf((*MockResult)(nil).LastInsertId)) } -// RowsAffected mocks base method +// RowsAffected mocks base method. func (m *MockResult) RowsAffected() (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RowsAffected") @@ -243,36 +244,36 @@ func (m *MockResult) RowsAffected() (int64, error) { return ret0, ret1 } -// RowsAffected indicates an expected call of RowsAffected +// RowsAffected indicates an expected call of RowsAffected. func (mr *MockResultMockRecorder) RowsAffected() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RowsAffected", reflect.TypeOf((*MockResult)(nil).RowsAffected)) } -// MockRows is a mock of Rows interface +// MockRows is a mock of Rows interface. type MockRows struct { ctrl *gomock.Controller recorder *MockRowsMockRecorder } -// MockRowsMockRecorder is the mock recorder for MockRows +// MockRowsMockRecorder is the mock recorder for MockRows. type MockRowsMockRecorder struct { mock *MockRows } -// NewMockRows creates a new mock instance +// NewMockRows creates a new mock instance. func NewMockRows(ctrl *gomock.Controller) *MockRows { mock := &MockRows{ctrl: ctrl} mock.recorder = &MockRowsMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use +// EXPECT returns an object that allows the caller to indicate expected use. func (m *MockRows) EXPECT() *MockRowsMockRecorder { return m.recorder } -// Close mocks base method +// Close mocks base method. func (m *MockRows) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -280,13 +281,13 @@ func (m *MockRows) Close() error { return ret0 } -// Close indicates an expected call of Close +// Close indicates an expected call of Close. func (mr *MockRowsMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRows)(nil).Close)) } -// Columns mocks base method +// Columns mocks base method. func (m *MockRows) Columns() []string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Columns") @@ -294,13 +295,13 @@ func (m *MockRows) Columns() []string { return ret0 } -// Columns indicates an expected call of Columns +// Columns indicates an expected call of Columns. func (mr *MockRowsMockRecorder) Columns() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Columns", reflect.TypeOf((*MockRows)(nil).Columns)) } -// Next mocks base method +// Next mocks base method. func (m *MockRows) Next(arg0 []driver.Value) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Next", arg0) @@ -308,7 +309,7 @@ func (m *MockRows) Next(arg0 []driver.Value) error { return ret0 } -// Next indicates an expected call of Next +// Next indicates an expected call of Next. func (mr *MockRowsMockRecorder) Next(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockRows)(nil).Next), arg0) diff --git a/example/sql_str.go b/example/sql_str.go index d1563ff6..b46029de 100644 --- a/example/sql_str.go +++ b/example/sql_str.go @@ -1,4 +1,4 @@ -//go:generate ../bin/go-enum -f=$GOFILE --sql --sqlnullstr +//go:generate ../bin/go-enum --sql --sqlnullstr -b example package example diff --git a/example/sql_str_enum.go b/example/sql_str_enum.go index 2cb67016..a9402dff 100644 --- a/example/sql_str_enum.go +++ b/example/sql_str_enum.go @@ -1,5 +1,11 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example @@ -20,13 +26,15 @@ const ( JobStateFailed ) +var ErrInvalidJobState = errors.New("not a valid JobState") + const _JobStateName = "pendingprocessingcompletedfailed" var _JobStateMap = map[JobState]string{ - 0: _JobStateName[0:7], - 1: _JobStateName[7:17], - 2: _JobStateName[17:26], - 3: _JobStateName[26:32], + JobStatePending: _JobStateName[0:7], + JobStateProcessing: _JobStateName[7:17], + JobStateCompleted: _JobStateName[17:26], + JobStateFailed: _JobStateName[26:32], } // String implements the Stringer interface. @@ -37,22 +45,29 @@ func (x JobState) String() string { return fmt.Sprintf("JobState(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x JobState) IsValid() bool { + _, ok := _JobStateMap[x] + return ok +} + var _JobStateValue = map[string]JobState{ - _JobStateName[0:7]: 0, - _JobStateName[7:17]: 1, - _JobStateName[17:26]: 2, - _JobStateName[26:32]: 3, + _JobStateName[0:7]: JobStatePending, + _JobStateName[7:17]: JobStateProcessing, + _JobStateName[17:26]: JobStateCompleted, + _JobStateName[26:32]: JobStateFailed, } -// ParseJobState attempts to convert a string to a JobState +// ParseJobState attempts to convert a string to a JobState. func ParseJobState(name string) (JobState, error) { if x, ok := _JobStateValue[name]; ok { return x, nil } - return JobState(0), fmt.Errorf("%s is not a valid JobState", name) + return JobState(0), fmt.Errorf("%s is %w", name, ErrInvalidJobState) } -var _JobStateErrNilPtr = errors.New("value pointer is nil") // one per type for package clashes +var errJobStateNilPtr = errors.New("value pointer is nil") // one per type for package clashes // Scan implements the Scanner interface. func (x *JobState) Scan(value interface{}) (err error) { @@ -76,7 +91,7 @@ func (x *JobState) Scan(value interface{}) (err error) { *x = JobState(v) case *JobState: if v == nil { - return _JobStateErrNilPtr + return errJobStateNilPtr } *x = *v case uint: @@ -85,34 +100,34 @@ func (x *JobState) Scan(value interface{}) (err error) { *x = JobState(v) case *int: if v == nil { - return _JobStateErrNilPtr + return errJobStateNilPtr } *x = JobState(*v) case *int64: if v == nil { - return _JobStateErrNilPtr + return errJobStateNilPtr } *x = JobState(*v) case float64: // json marshals everything as a float64 if it's a number *x = JobState(v) case *float64: // json marshals everything as a float64 if it's a number if v == nil { - return _JobStateErrNilPtr + return errJobStateNilPtr } *x = JobState(*v) case *uint: if v == nil { - return _JobStateErrNilPtr + return errJobStateNilPtr } *x = JobState(*v) case *uint64: if v == nil { - return _JobStateErrNilPtr + return errJobStateNilPtr } *x = JobState(*v) case *string: if v == nil { - return _JobStateErrNilPtr + return errJobStateNilPtr } *x, err = ParseJobState(*v) } diff --git a/example/sql_str_enum_test.go b/example/sql_str_enum_test.go index 9e4d09f3..9d8b9348 100644 --- a/example/sql_str_enum_test.go +++ b/example/sql_str_enum_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( @@ -11,7 +14,6 @@ import ( ) func TestExampleSQLStrOnly(t *testing.T) { - tests := map[string]struct { setupMock func(t testing.TB, mocks *MockSQL) tester func(t testing.TB, db *sql.DB) @@ -284,7 +286,6 @@ func TestExampleSQLStrOnly(t *testing.T) { for name, tc := range tests { t.Run(name, func(t *testing.T) { - require.NotNil(t, tc.setupMock) require.NotNil(t, tc.tester) @@ -300,7 +301,6 @@ func TestExampleSQLStrOnly(t *testing.T) { tc.setupMock(t, mocks) tc.tester(t, conn) - }) } } @@ -321,7 +321,6 @@ func setJobState(db *sql.DB, state interface{}) error { } func TestSQLStrExtras(t *testing.T) { - assert.Equal(t, "JobState(22)", JobState(22).String(), "String value is not correct") _, err := ParseJobState(`NotAStatus`) @@ -423,8 +422,6 @@ func TestSQLStrExtras(t *testing.T) { t.Run(name, func(t *testing.T) { status := NewNullJobState(tc.input) assert.Equal(t, status, tc.result) - }) } - } diff --git a/example/sql_str_int.go b/example/sql_str_int.go new file mode 100644 index 00000000..c258969b --- /dev/null +++ b/example/sql_str_int.go @@ -0,0 +1,9 @@ +//go:generate ../bin/go-enum -f=$GOFILE --sqlint --sqlnullint --names -b example + +package example + +// ENUM(_,zeus, apollo, athena=20, ares) +type GreekGod string + +// ENUM(_,zeus, apollo, _=19, athena="20", ares) +type GreekGodCustom string diff --git a/example/sql_str_int_enum.go b/example/sql_str_int_enum.go new file mode 100644 index 00000000..a1218b90 --- /dev/null +++ b/example/sql_str_int_enum.go @@ -0,0 +1,408 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "database/sql/driver" + "errors" + "fmt" + "strconv" + "strings" +) + +const ( + // Skipped value. + _ GreekGod = "_" + // GreekGodZeus is a GreekGod of type zeus. + GreekGodZeus GreekGod = "zeus" + // GreekGodApollo is a GreekGod of type apollo. + GreekGodApollo GreekGod = "apollo" + // GreekGodAthena is a GreekGod of type athena. + GreekGodAthena GreekGod = "athena" + // GreekGodAres is a GreekGod of type ares. + GreekGodAres GreekGod = "ares" +) + +var ErrInvalidGreekGod = fmt.Errorf("not a valid GreekGod, try [%s]", strings.Join(_GreekGodNames, ", ")) + +var _GreekGodNames = []string{ + string(GreekGodZeus), + string(GreekGodApollo), + string(GreekGodAthena), + string(GreekGodAres), +} + +// GreekGodNames returns a list of possible string values of GreekGod. +func GreekGodNames() []string { + tmp := make([]string, len(_GreekGodNames)) + copy(tmp, _GreekGodNames) + return tmp +} + +// String implements the Stringer interface. +func (x GreekGod) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x GreekGod) IsValid() bool { + _, err := ParseGreekGod(string(x)) + return err == nil +} + +var _GreekGodValue = map[string]GreekGod{ + "zeus": GreekGodZeus, + "apollo": GreekGodApollo, + "athena": GreekGodAthena, + "ares": GreekGodAres, +} + +// ParseGreekGod attempts to convert a string to a GreekGod. +func ParseGreekGod(name string) (GreekGod, error) { + if x, ok := _GreekGodValue[name]; ok { + return x, nil + } + return GreekGod(""), fmt.Errorf("%s is %w", name, ErrInvalidGreekGod) +} + +var errGreekGodNilPtr = errors.New("value pointer is nil") // one per type for package clashes + +var sqlIntGreekGodMap = map[int64]GreekGod{ + 1: GreekGodZeus, + 2: GreekGodApollo, + 20: GreekGodAthena, + 21: GreekGodAres, +} + +var sqlIntGreekGodValue = map[GreekGod]int64{ + GreekGodZeus: 1, + GreekGodApollo: 2, + GreekGodAthena: 20, + GreekGodAres: 21, +} + +func lookupSqlIntGreekGod(val int64) (GreekGod, error) { + x, ok := sqlIntGreekGodMap[val] + if !ok { + return x, fmt.Errorf("%v is not %w", val, ErrInvalidGreekGod) + } + return x, nil +} + +// Scan implements the Scanner interface. +func (x *GreekGod) Scan(value interface{}) (err error) { + if value == nil { + *x = GreekGod("") + return + } + + // A wider range of scannable types. + // driver.Value values at the top of the list for expediency + switch v := value.(type) { + case int64: + *x, err = lookupSqlIntGreekGod(v) + case string: + *x, err = ParseGreekGod(v) + case []byte: + if val, verr := strconv.ParseInt(string(v), 10, 64); verr == nil { + *x, err = lookupSqlIntGreekGod(val) + } else { + // try parsing the value as a string + *x, err = ParseGreekGod(string(v)) + } + case GreekGod: + *x = v + case int: + *x, err = lookupSqlIntGreekGod(int64(v)) + case *GreekGod: + if v == nil { + return errGreekGodNilPtr + } + *x = *v + case uint: + *x, err = lookupSqlIntGreekGod(int64(v)) + case uint64: + *x, err = lookupSqlIntGreekGod(int64(v)) + case *int: + if v == nil { + return errGreekGodNilPtr + } + *x, err = lookupSqlIntGreekGod(int64(*v)) + case *int64: + if v == nil { + return errGreekGodNilPtr + } + *x, err = lookupSqlIntGreekGod(int64(*v)) + case float64: // json marshals everything as a float64 if it's a number + *x, err = lookupSqlIntGreekGod(int64(v)) + case *float64: // json marshals everything as a float64 if it's a number + if v == nil { + return errGreekGodNilPtr + } + *x, err = lookupSqlIntGreekGod(int64(*v)) + case *uint: + if v == nil { + return errGreekGodNilPtr + } + *x, err = lookupSqlIntGreekGod(int64(*v)) + case *uint64: + if v == nil { + return errGreekGodNilPtr + } + *x, err = lookupSqlIntGreekGod(int64(*v)) + case *string: + if v == nil { + return errGreekGodNilPtr + } + *x, err = ParseGreekGod(*v) + default: + return errors.New("invalid type for GreekGod") + } + + return +} + +// Value implements the driver Valuer interface. +func (x GreekGod) Value() (driver.Value, error) { + val, ok := sqlIntGreekGodValue[x] + if !ok { + return nil, ErrInvalidGreekGod + } + return int64(val), nil +} + +type NullGreekGod struct { + GreekGod GreekGod + Valid bool +} + +func NewNullGreekGod(val interface{}) (x NullGreekGod) { + err := x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + _ = err // make any errcheck linters happy + return +} + +// Scan implements the Scanner interface. +func (x *NullGreekGod) Scan(value interface{}) (err error) { + if value == nil { + x.GreekGod, x.Valid = GreekGod(""), false + return + } + + err = x.GreekGod.Scan(value) + x.Valid = (err == nil) + return +} + +// Value implements the driver Valuer interface. +func (x NullGreekGod) Value() (driver.Value, error) { + if !x.Valid { + return nil, nil + } + // driver.Value accepts int64 for int values. + return string(x.GreekGod), nil +} + +const ( + // Skipped value. + _ GreekGodCustom = "_" + // GreekGodCustomZeus is a GreekGodCustom of type zeus. + GreekGodCustomZeus GreekGodCustom = "zeus" + // GreekGodCustomApollo is a GreekGodCustom of type apollo. + GreekGodCustomApollo GreekGodCustom = "apollo" + // Skipped value. + _ GreekGodCustom = "_" + // GreekGodCustomAthena is a GreekGodCustom of type athena. + GreekGodCustomAthena GreekGodCustom = "20" + // GreekGodCustomAres is a GreekGodCustom of type ares. + GreekGodCustomAres GreekGodCustom = "ares" +) + +var ErrInvalidGreekGodCustom = fmt.Errorf("not a valid GreekGodCustom, try [%s]", strings.Join(_GreekGodCustomNames, ", ")) + +var _GreekGodCustomNames = []string{ + string(GreekGodCustomZeus), + string(GreekGodCustomApollo), + string(GreekGodCustomAthena), + string(GreekGodCustomAres), +} + +// GreekGodCustomNames returns a list of possible string values of GreekGodCustom. +func GreekGodCustomNames() []string { + tmp := make([]string, len(_GreekGodCustomNames)) + copy(tmp, _GreekGodCustomNames) + return tmp +} + +// String implements the Stringer interface. +func (x GreekGodCustom) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x GreekGodCustom) IsValid() bool { + _, err := ParseGreekGodCustom(string(x)) + return err == nil +} + +var _GreekGodCustomValue = map[string]GreekGodCustom{ + "zeus": GreekGodCustomZeus, + "apollo": GreekGodCustomApollo, + "20": GreekGodCustomAthena, + "ares": GreekGodCustomAres, +} + +// ParseGreekGodCustom attempts to convert a string to a GreekGodCustom. +func ParseGreekGodCustom(name string) (GreekGodCustom, error) { + if x, ok := _GreekGodCustomValue[name]; ok { + return x, nil + } + return GreekGodCustom(""), fmt.Errorf("%s is %w", name, ErrInvalidGreekGodCustom) +} + +var errGreekGodCustomNilPtr = errors.New("value pointer is nil") // one per type for package clashes + +var sqlIntGreekGodCustomMap = map[int64]GreekGodCustom{ + 1: GreekGodCustomZeus, + 2: GreekGodCustomApollo, + 20: GreekGodCustomAthena, + 21: GreekGodCustomAres, +} + +var sqlIntGreekGodCustomValue = map[GreekGodCustom]int64{ + GreekGodCustomZeus: 1, + GreekGodCustomApollo: 2, + GreekGodCustomAthena: 20, + GreekGodCustomAres: 21, +} + +func lookupSqlIntGreekGodCustom(val int64) (GreekGodCustom, error) { + x, ok := sqlIntGreekGodCustomMap[val] + if !ok { + return x, fmt.Errorf("%v is not %w", val, ErrInvalidGreekGodCustom) + } + return x, nil +} + +// Scan implements the Scanner interface. +func (x *GreekGodCustom) Scan(value interface{}) (err error) { + if value == nil { + *x = GreekGodCustom("") + return + } + + // A wider range of scannable types. + // driver.Value values at the top of the list for expediency + switch v := value.(type) { + case int64: + *x, err = lookupSqlIntGreekGodCustom(v) + case string: + *x, err = ParseGreekGodCustom(v) + case []byte: + if val, verr := strconv.ParseInt(string(v), 10, 64); verr == nil { + *x, err = lookupSqlIntGreekGodCustom(val) + } else { + // try parsing the value as a string + *x, err = ParseGreekGodCustom(string(v)) + } + case GreekGodCustom: + *x = v + case int: + *x, err = lookupSqlIntGreekGodCustom(int64(v)) + case *GreekGodCustom: + if v == nil { + return errGreekGodCustomNilPtr + } + *x = *v + case uint: + *x, err = lookupSqlIntGreekGodCustom(int64(v)) + case uint64: + *x, err = lookupSqlIntGreekGodCustom(int64(v)) + case *int: + if v == nil { + return errGreekGodCustomNilPtr + } + *x, err = lookupSqlIntGreekGodCustom(int64(*v)) + case *int64: + if v == nil { + return errGreekGodCustomNilPtr + } + *x, err = lookupSqlIntGreekGodCustom(int64(*v)) + case float64: // json marshals everything as a float64 if it's a number + *x, err = lookupSqlIntGreekGodCustom(int64(v)) + case *float64: // json marshals everything as a float64 if it's a number + if v == nil { + return errGreekGodCustomNilPtr + } + *x, err = lookupSqlIntGreekGodCustom(int64(*v)) + case *uint: + if v == nil { + return errGreekGodCustomNilPtr + } + *x, err = lookupSqlIntGreekGodCustom(int64(*v)) + case *uint64: + if v == nil { + return errGreekGodCustomNilPtr + } + *x, err = lookupSqlIntGreekGodCustom(int64(*v)) + case *string: + if v == nil { + return errGreekGodCustomNilPtr + } + *x, err = ParseGreekGodCustom(*v) + default: + return errors.New("invalid type for GreekGodCustom") + } + + return +} + +// Value implements the driver Valuer interface. +func (x GreekGodCustom) Value() (driver.Value, error) { + val, ok := sqlIntGreekGodCustomValue[x] + if !ok { + return nil, ErrInvalidGreekGodCustom + } + return int64(val), nil +} + +type NullGreekGodCustom struct { + GreekGodCustom GreekGodCustom + Valid bool +} + +func NewNullGreekGodCustom(val interface{}) (x NullGreekGodCustom) { + err := x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + _ = err // make any errcheck linters happy + return +} + +// Scan implements the Scanner interface. +func (x *NullGreekGodCustom) Scan(value interface{}) (err error) { + if value == nil { + x.GreekGodCustom, x.Valid = GreekGodCustom(""), false + return + } + + err = x.GreekGodCustom.Scan(value) + x.Valid = (err == nil) + return +} + +// Value implements the driver Valuer interface. +func (x NullGreekGodCustom) Value() (driver.Value, error) { + if !x.Valid { + return nil, nil + } + // driver.Value accepts int64 for int values. + return string(x.GreekGodCustom), nil +} diff --git a/example/sql_str_int_enum_test.go b/example/sql_str_int_enum_test.go new file mode 100644 index 00000000..7c8c140b --- /dev/null +++ b/example/sql_str_int_enum_test.go @@ -0,0 +1,429 @@ +//go:build example +// +build example + +package example + +import ( + "database/sql" + driver "database/sql/driver" + "errors" + "testing" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestExampleSQLStrIntOnly(t *testing.T) { + tests := map[string]struct { + setupMock func(t testing.TB, mocks *MockSQL) + tester func(t testing.TB, db *sql.DB) + }{ + "NonNullable select nil": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{nil}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.Equal(t, GreekGod(""), god) + }, + }, + "Nullable Select Null": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{nil}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.False(t, god.Valid) + }, + }, + "Select a string": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{GreekGodAthena.String()}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.Equal(t, GreekGodAthena, god) + }, + }, + "Nullable select an int": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{int(2)}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.True(t, god.Valid) + require.Equal(t, GreekGodApollo, god.GreekGod) + }, + }, + "Nullable select an int64": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{int64(2)}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.True(t, god.Valid) + require.Equal(t, GreekGodApollo, god.GreekGod) + }, + }, + "Nullable select an uint": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{uint(2)}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.True(t, god.Valid) + require.Equal(t, GreekGodApollo, god.GreekGod) + }, + }, + "Nullable select an uint64": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{uint64(2)}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.True(t, god.Valid) + require.Equal(t, GreekGodApollo, god.GreekGod) + }, + }, + "Nullable select an *uint64": { + setupMock: func(t testing.TB, mocks *MockSQL) { + val := uint64(2) + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{&val}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.True(t, god.Valid) + require.Equal(t, GreekGodApollo, god.GreekGod) + }, + }, + "Nullable select an *int64": { + setupMock: func(t testing.TB, mocks *MockSQL) { + val := int64(2) + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{&val}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.True(t, god.Valid) + require.Equal(t, GreekGodApollo, god.GreekGod) + }, + }, + "Nullable select an *uint": { + setupMock: func(t testing.TB, mocks *MockSQL) { + val := uint(2) + gomock.InOrder( + // Select In Work + mocks.Conn.EXPECT().Prepare("SELECT god FROM job WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(1), + mocks.Stmt.EXPECT().Query(gomock.Any()).Return(mocks.Rows, nil), + mocks.Rows.EXPECT().Columns().Return([]string{`god`}), + mocks.Rows.EXPECT().Next(gomock.Any()).SetArg(0, []driver.Value{&val}).Return(nil), + mocks.Rows.EXPECT().Close().Return(nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + god, err := getNullGreekGod(conn) + require.NoError(t, err, "failed getting project god") + require.True(t, god.Valid) + require.Equal(t, GreekGodApollo, god.GreekGod) + }, + }, + "standard update": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Update value + mocks.Conn.EXPECT().Prepare("Update job SET god = ? WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(2), + mocks.Stmt.EXPECT().Exec(MatchesValues(sqlIntGreekGodValue[GreekGodAres], hardcodedProjectID)).Return(mocks.Result, nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + err := setGreekGod(conn, GreekGodAres) + require.NoError(t, err, "failed updating project god") + }, + }, + "nullable string update": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Update value + mocks.Conn.EXPECT().Prepare("Update job SET god = ? WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(2), + mocks.Stmt.EXPECT().Exec(MatchesValues(GreekGodAres.String(), hardcodedProjectID)).Return(mocks.Result, nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + err := setGreekGod(conn, NewNullGreekGod(GreekGodAres)) + require.NoError(t, err, "failed updating project god") + }, + }, + "nullable invalid string update": { + setupMock: func(t testing.TB, mocks *MockSQL) { + gomock.InOrder( + // Update value + mocks.Conn.EXPECT().Prepare("Update job SET god = ? WHERE id = ?").Return(mocks.Stmt, nil), + mocks.Stmt.EXPECT().NumInput().Return(2), + mocks.Stmt.EXPECT().Exec(MatchesValues(nil, hardcodedProjectID)).Return(mocks.Result, nil), + mocks.Stmt.EXPECT().Close().Return(nil), + ) + }, + tester: func(t testing.TB, conn *sql.DB) { + // Get inWork god + err := setGreekGod(conn, NullGreekGod{}) + require.NoError(t, err, "failed updating project god") + }, + }, + } + + driverctrl := gomock.NewController(t) + driver := NewMockDriver(driverctrl) + defer func() { + driverctrl.Finish() + }() + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + require.NotNil(t, tc.setupMock) + require.NotNil(t, tc.tester) + + sql.Register(t.Name(), driver) + mocks, finish := WithMockSQL(t) + defer finish() + + driver.EXPECT().Open(dataSourceName).Return(mocks.Conn, nil) + + conn, err := sql.Open(t.Name(), dataSourceName) + require.NoError(t, err, "failed opening mock db") + + tc.setupMock(t, mocks) + + tc.tester(t, conn) + }) + } +} + +func getGreekGod(db *sql.DB) (state GreekGod, err error) { + err = db.QueryRow(`SELECT god FROM job WHERE id = ?`, hardcodedProjectID).Scan(&state) + return +} + +func getNullGreekGod(db *sql.DB) (state NullGreekGod, err error) { + err = db.QueryRow(`SELECT god FROM job WHERE id = ?`, hardcodedProjectID).Scan(&state) + return +} + +func setGreekGod(db *sql.DB, state interface{}) error { + _, err := db.Exec(`Update job SET god = ? WHERE id = ?`, state, hardcodedProjectID) + return err +} + +func TestSQLStrIntExtras(t *testing.T) { + assert.Equal(t, sqlIntGreekGodMap[20], GreekGod("athena"), "String value is not correct") + + _, err := ParseGreekGod(`NotAStatus`) + assert.Error(t, err, "Should have had an error parsing a non god") + assert.True(t, errors.Is(err, ErrInvalidGreekGod)) + + var ( + intVal int = 3 + strVal string = "completed" + enumVal JobState = JobStateCompleted + nullInt *int + nullInt64 *int64 + nullUint *uint + nullUint64 *uint64 + nullString *string + nullJobState *JobState + ) + + tests := map[string]struct { + input interface{} + result NullJobState + }{ + "nil": {}, + "val": { + input: JobStateFailed, + result: NullJobState{ + JobState: JobStateFailed, + Valid: true, + }, + }, + "ptr": { + input: &enumVal, + result: NullJobState{ + JobState: JobStateCompleted, + Valid: true, + }, + }, + "string": { + input: strVal, + result: NullJobState{ + JobState: JobStateCompleted, + Valid: true, + }, + }, + "*string": { + input: &strVal, + result: NullJobState{ + JobState: JobStateCompleted, + Valid: true, + }, + }, + "invalid string": { + input: "random value", + }, + "[]byte": { + input: []byte(JobStateProcessing.String()), + result: NullJobState{ + JobState: JobStateProcessing, + Valid: true, + }, + }, + "int": { + input: intVal, + result: NullJobState{ + JobState: JobStateFailed, + Valid: true, + }, + }, + "*int": { + input: &intVal, + result: NullJobState{ + JobState: JobStateFailed, + Valid: true, + }, + }, + "nullInt": { + input: nullInt, + }, + "nullInt64": { + input: nullInt64, + }, + "nullUint": { + input: nullUint, + }, + "nullUint64": { + input: nullUint64, + }, + "nullString": { + input: nullString, + }, + "nullImageType": { + input: nullJobState, + }, + "int as []byte": { // must have --sqlnullint flag to get this feature. + input: []byte("3"), + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + god := NewNullJobState(tc.input) + assert.Equal(t, god, tc.result) + }) + } +} diff --git a/example/sql_test.go b/example/sql_test.go index 09007528..3d648b42 100644 --- a/example/sql_test.go +++ b/example/sql_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( @@ -9,7 +12,6 @@ import ( ) func TestSQLExtras(t *testing.T) { - assert.Equal(t, "ProjectStatus(22)", ProjectStatus(22).String(), "String value is not correct") _, err := ParseProjectStatus(`NotAStatus`) @@ -129,7 +131,6 @@ func TestSQLExtras(t *testing.T) { assert.Equal(t, tc.result, status) }) } - } type SQLMarshalType struct { @@ -139,7 +140,6 @@ type SQLMarshalType struct { } func TestSQLMarshal(t *testing.T) { - var val SQLMarshalType var val2 SQLMarshalType @@ -197,5 +197,4 @@ func TestSQLMarshal(t *testing.T) { assert.Equal(t, val, val2) require.Error(t, json.Unmarshal([]byte(`{"status2":"xyz"}`), &val2)) - } diff --git a/example/strings_only.go b/example/strings_only.go new file mode 100644 index 00000000..d8b38648 --- /dev/null +++ b/example/strings_only.go @@ -0,0 +1,6 @@ +//go:generate ../bin/go-enum --ptr --marshal --flag --nocase --mustparse --sqlnullstr --sql --names --values --nocomments -b example + +package example + +// ENUM(pending, running, completed, failed=error) +type StrState string diff --git a/example/strings_only_enum.go b/example/strings_only_enum.go new file mode 100644 index 00000000..3a2790ed --- /dev/null +++ b/example/strings_only_enum.go @@ -0,0 +1,220 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "database/sql/driver" + json "encoding/json" + "errors" + "fmt" + "strings" +) + +const ( + StrStatePending StrState = "pending" + StrStateRunning StrState = "running" + StrStateCompleted StrState = "completed" + StrStateFailed StrState = "error" +) + +var ErrInvalidStrState = fmt.Errorf("not a valid StrState, try [%s]", strings.Join(_StrStateNames, ", ")) + +var _StrStateNames = []string{ + string(StrStatePending), + string(StrStateRunning), + string(StrStateCompleted), + string(StrStateFailed), +} + +// StrStateNames returns a list of possible string values of StrState. +func StrStateNames() []string { + tmp := make([]string, len(_StrStateNames)) + copy(tmp, _StrStateNames) + return tmp +} + +// StrStateValues returns a list of the values for StrState +func StrStateValues() []StrState { + return []StrState{ + StrStatePending, + StrStateRunning, + StrStateCompleted, + StrStateFailed, + } +} + +// String implements the Stringer interface. +func (x StrState) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x StrState) IsValid() bool { + _, err := ParseStrState(string(x)) + return err == nil +} + +var _StrStateValue = map[string]StrState{ + "pending": StrStatePending, + "running": StrStateRunning, + "completed": StrStateCompleted, + "error": StrStateFailed, +} + +// ParseStrState attempts to convert a string to a StrState. +func ParseStrState(name string) (StrState, error) { + if x, ok := _StrStateValue[name]; ok { + return x, nil + } + // Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to. + if x, ok := _StrStateValue[strings.ToLower(name)]; ok { + return x, nil + } + return StrState(""), fmt.Errorf("%s is %w", name, ErrInvalidStrState) +} + +// MustParseStrState converts a string to a StrState, and panics if is not valid. +func MustParseStrState(name string) StrState { + val, err := ParseStrState(name) + if err != nil { + panic(err) + } + return val +} + +func (x StrState) Ptr() *StrState { + return &x +} + +// MarshalText implements the text marshaller method. +func (x StrState) MarshalText() ([]byte, error) { + return []byte(string(x)), nil +} + +// UnmarshalText implements the text unmarshaller method. +func (x *StrState) UnmarshalText(text []byte) error { + tmp, err := ParseStrState(string(text)) + if err != nil { + return err + } + *x = tmp + return nil +} + +var errStrStateNilPtr = errors.New("value pointer is nil") // one per type for package clashes + +// Scan implements the Scanner interface. +func (x *StrState) Scan(value interface{}) (err error) { + if value == nil { + *x = StrState("") + return + } + + // A wider range of scannable types. + // driver.Value values at the top of the list for expediency + switch v := value.(type) { + case string: + *x, err = ParseStrState(v) + case []byte: + *x, err = ParseStrState(string(v)) + case StrState: + *x = v + case *StrState: + if v == nil { + return errStrStateNilPtr + } + *x = *v + case *string: + if v == nil { + return errStrStateNilPtr + } + *x, err = ParseStrState(*v) + default: + return errors.New("invalid type for StrState") + } + + return +} + +// Value implements the driver Valuer interface. +func (x StrState) Value() (driver.Value, error) { + return x.String(), nil +} + +// Set implements the Golang flag.Value interface func. +func (x *StrState) Set(val string) error { + v, err := ParseStrState(val) + *x = v + return err +} + +// Get implements the Golang flag.Getter interface func. +func (x *StrState) Get() interface{} { + return *x +} + +// Type implements the github.com/spf13/pFlag Value interface. +func (x *StrState) Type() string { + return "StrState" +} + +type NullStrState struct { + StrState StrState + Valid bool + Set bool +} + +func NewNullStrState(val interface{}) (x NullStrState) { + err := x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + _ = err // make any errcheck linters happy + return +} + +// Scan implements the Scanner interface. +func (x *NullStrState) Scan(value interface{}) (err error) { + if value == nil { + x.StrState, x.Valid = StrState(""), false + return + } + + err = x.StrState.Scan(value) + x.Valid = (err == nil) + return +} + +// Value implements the driver Valuer interface. +func (x NullStrState) Value() (driver.Value, error) { + if !x.Valid { + return nil, nil + } + return x.StrState.String(), nil +} + +// MarshalJSON correctly serializes a NullStrState to JSON. +func (n NullStrState) MarshalJSON() ([]byte, error) { + const nullStr = "null" + if n.Valid { + return json.Marshal(n.StrState) + } + return []byte(nullStr), nil +} + +// UnmarshalJSON correctly deserializes a NullStrState from JSON. +func (n *NullStrState) UnmarshalJSON(b []byte) error { + n.Set = true + var x interface{} + err := json.Unmarshal(b, &x) + if err != nil { + return err + } + err = n.Scan(x) + return err +} diff --git a/example/strings_only_test.go b/example/strings_only_test.go new file mode 100644 index 00000000..8111043f --- /dev/null +++ b/example/strings_only_test.go @@ -0,0 +1,258 @@ +//go:build example +// +build example + +package example + +import ( + "encoding/json" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestStrState(t *testing.T) { + x := StrState("") + assert.Equal(t, "", x.String()) + + assert.Equal(t, StrState("pending"), StrStatePending) + assert.Equal(t, StrState("running"), StrStateRunning) + assert.Equal(t, &x, StrState("").Ptr()) +} + +func TestStrStateMustParse(t *testing.T) { + x := `avocado` + + assert.PanicsWithError(t, x+" is not a valid StrState, try [pending, running, completed, error]", func() { MustParseStrState(x) }) + assert.NotPanics(t, func() { MustParseStrState(StrStateFailed.String()) }) +} + +func TestStrStateUnmarshal(t *testing.T) { + type testData struct { + StrStateX StrState `json:"state"` + } + tests := []struct { + name string + input string + output *testData + errorExpected bool + err error + }{ + { + name: "pending", + input: `{"state":"Pending"}`, + output: &testData{StrStateX: StrStatePending}, + errorExpected: false, + err: nil, + }, + { + name: "pendinglower", + input: `{"state":"pending"}`, + output: &testData{StrStateX: StrStatePending}, + errorExpected: false, + err: nil, + }, + { + name: "running", + input: `{"state":"RUNNING"}`, + output: &testData{StrStateX: StrStateRunning}, + errorExpected: false, + err: nil, + }, + { + name: "running", + input: `{"state":"running"}`, + output: &testData{StrStateX: StrStateRunning}, + errorExpected: false, + err: nil, + }, + { + name: "completed", + input: `{"state":"Completed"}`, + output: &testData{StrStateX: StrStateCompleted}, + errorExpected: false, + err: nil, + }, + { + name: "completedlower", + input: `{"state":"completed"}`, + output: &testData{StrStateX: StrStateCompleted}, + errorExpected: false, + err: nil, + }, + { + name: "failed", + input: `{"state":"Error"}`, + output: &testData{StrStateX: StrStateFailed}, + errorExpected: false, + err: nil, + }, + { + name: "failedlower", + input: `{"state":"error"}`, + output: &testData{StrStateX: StrStateFailed}, + errorExpected: false, + err: nil, + }, + } + + for _, test := range tests { + t.Run(test.name, func(tt *testing.T) { + x := &testData{} + err := json.Unmarshal([]byte(test.input), x) + if !test.errorExpected { + require.NoError(tt, err, "failed unmarshalling the json.") + assert.Equal(tt, test.output.StrStateX, x.StrStateX) + } else { + require.Error(tt, err) + assert.EqualError(tt, err, test.err.Error()) + } + }) + } +} + +func TestStrStateMarshal(t *testing.T) { + type testData struct { + StrStateX StrState `json:"state"` + } + tests := []struct { + name string + input *testData + output string + errorExpected bool + err error + }{ + { + name: "black", + output: `{"state":"pending"}`, + input: &testData{StrStateX: StrStatePending}, + errorExpected: false, + err: nil, + }, + { + name: "white", + output: `{"state":"running"}`, + input: &testData{StrStateX: StrStateRunning}, + errorExpected: false, + err: nil, + }, + { + name: "red", + output: `{"state":"completed"}`, + input: &testData{StrStateX: StrStateCompleted}, + errorExpected: false, + err: nil, + }, + { + name: "green", + output: `{"state":"error"}`, + input: &testData{StrStateX: StrStateFailed}, + errorExpected: false, + err: nil, + }, + } + + for _, test := range tests { + t.Run(test.name, func(tt *testing.T) { + raw, err := json.Marshal(test.input) + require.NoError(tt, err, "failed marshalling to json") + assert.JSONEq(tt, test.output, string(raw)) + }) + } +} + +func TestStrStateSQLExtras(t *testing.T) { + _, err := ParseStrState(`NotAState`) + assert.Error(t, err, "Should have had an error parsing a non status") + + var ( + intVal int = 3 + strVal string = "completed" + enumVal StrState = StrStateCompleted + nullInt *int + nullInt64 *int64 + nullUint *uint + nullUint64 *uint64 + nullString *string + nullStrState *StrState + ) + + tests := map[string]struct { + input interface{} + result NullStrState + }{ + "nil": {}, + "val": { + input: StrStatePending, + result: NullStrState{ + StrState: StrStatePending, + Valid: true, + }, + }, + "ptr": { + input: &enumVal, + result: NullStrState{ + StrState: StrStateCompleted, + Valid: true, + }, + }, + "string": { + input: strVal, + result: NullStrState{ + StrState: StrStateCompleted, + Valid: true, + }, + }, + "*string": { + input: &strVal, + result: NullStrState{ + StrState: StrStateCompleted, + Valid: true, + }, + }, + "invalid string": { + input: "random value", + }, + "[]byte": { + input: []byte(StrStateRunning.String()), + result: NullStrState{ + StrState: StrStateRunning, + Valid: true, + }, + }, + "int": { + input: intVal, + }, + "*int": { + input: &intVal, + }, + "nullInt": { + input: nullInt, + }, + "nullInt64": { + input: nullInt64, + }, + "nullUint": { + input: nullUint, + }, + "nullUint64": { + input: nullUint64, + }, + "nullString": { + input: nullString, + }, + "nullImageType": { + input: nullStrState, + }, + "int as []byte": { // must have --sqlnullint flag to get this feature. + input: []byte("3"), + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + status := NewNullStrState(tc.input) + assert.Equal(t, status, tc.result) + }) + } +} diff --git a/example/suffix.enum.gen.go b/example/suffix.enum.gen.go new file mode 100644 index 00000000..cd739a22 --- /dev/null +++ b/example/suffix.enum.gen.go @@ -0,0 +1,46 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "errors" + "fmt" +) + +const ( + // SuffixGen is a Suffix of type gen. + SuffixGen Suffix = "gen" +) + +var ErrInvalidSuffix = errors.New("not a valid Suffix") + +// String implements the Stringer interface. +func (x Suffix) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x Suffix) IsValid() bool { + _, err := ParseSuffix(string(x)) + return err == nil +} + +var _SuffixValue = map[string]Suffix{ + "gen": SuffixGen, +} + +// ParseSuffix attempts to convert a string to a Suffix. +func ParseSuffix(name string) (Suffix, error) { + if x, ok := _SuffixValue[name]; ok { + return x, nil + } + return Suffix(""), fmt.Errorf("%s is %w", name, ErrInvalidSuffix) +} diff --git a/example/suffix.enum.gen_test.go b/example/suffix.enum.gen_test.go new file mode 100644 index 00000000..265a8053 --- /dev/null +++ b/example/suffix.enum.gen_test.go @@ -0,0 +1,46 @@ +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example + +package example + +import ( + "errors" + "fmt" +) + +const ( + // SuffixTestSomeItem is a SuffixTest of type some_item. + SuffixTestSomeItem SuffixTest = "some_item" +) + +var ErrInvalidSuffixTest = errors.New("not a valid SuffixTest") + +// String implements the Stringer interface. +func (x SuffixTest) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x SuffixTest) IsValid() bool { + _, err := ParseSuffixTest(string(x)) + return err == nil +} + +var _SuffixTestValue = map[string]SuffixTest{ + "some_item": SuffixTestSomeItem, +} + +// ParseSuffixTest attempts to convert a string to a SuffixTest. +func ParseSuffixTest(name string) (SuffixTest, error) { + if x, ok := _SuffixTestValue[name]; ok { + return x, nil + } + return SuffixTest(""), fmt.Errorf("%s is %w", name, ErrInvalidSuffixTest) +} diff --git a/example/suffix.go b/example/suffix.go new file mode 100644 index 00000000..e757bf21 --- /dev/null +++ b/example/suffix.go @@ -0,0 +1,9 @@ +//go:generate ../bin/go-enum -b example --output-suffix .enum.gen + +//go:build example +// +build example + +package example + +// Suffix ENUM(gen) +type Suffix string diff --git a/example/suffix_test.go b/example/suffix_test.go new file mode 100644 index 00000000..d8f03442 --- /dev/null +++ b/example/suffix_test.go @@ -0,0 +1,29 @@ +//go:generate ../bin/go-enum -b example --output-suffix .enum.gen + +//go:build example +// +build example + +package example + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +// SuffixTest ENUM(some_item) +type SuffixTest string + +func TestSuffix(t *testing.T) { + x := Suffix("") + assert.Equal(t, "", x.String()) + + assert.Equal(t, Suffix("gen"), SuffixGen) +} + +func TestSuffixTest(t *testing.T) { + x := SuffixTest("") + assert.Equal(t, "", x.String()) + + assert.Equal(t, SuffixTest("some_item"), SuffixTestSomeItem) +} diff --git a/example/user_template.go b/example/user_template.go index 6527071b..2392acb1 100644 --- a/example/user_template.go +++ b/example/user_template.go @@ -1,4 +1,4 @@ -//go:generate ../bin/go-enum -f=$GOFILE -t user_template.tmpl -t *user_glob*.tmpl +//go:generate ../bin/go-enum -t user_template.tmpl -t *user_glob*.tmpl -b example package example diff --git a/example/user_template.tmpl b/example/user_template.tmpl index 7aab62bd..b34e9f53 100644 --- a/example/user_template.tmpl +++ b/example/user_template.tmpl @@ -2,3 +2,6 @@ func Parse{{.enum.Name}}Example() bool { return true } +func Parse{{.enum.Name}}Description() string { + return `{{.enum.Comment}}` +} diff --git a/example/user_template_enum.go b/example/user_template_enum.go index f5d8ed96..6c4ee425 100644 --- a/example/user_template_enum.go +++ b/example/user_template_enum.go @@ -1,9 +1,16 @@ -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: example +// Revision: example +// Build Date: example +// Built By: example + +//go:build example +// +build example package example import ( + "errors" "fmt" ) @@ -16,12 +23,14 @@ const ( OceanColorGreen ) +var ErrInvalidOceanColor = errors.New("not a valid OceanColor") + const _OceanColorName = "CeruleanBlueGreen" var _OceanColorMap = map[OceanColor]string{ - 0: _OceanColorName[0:8], - 1: _OceanColorName[8:12], - 2: _OceanColorName[12:17], + OceanColorCerulean: _OceanColorName[0:8], + OceanColorBlue: _OceanColorName[8:12], + OceanColorGreen: _OceanColorName[12:17], } // String implements the Stringer interface. @@ -32,18 +41,25 @@ func (x OceanColor) String() string { return fmt.Sprintf("OceanColor(%d)", x) } +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x OceanColor) IsValid() bool { + _, ok := _OceanColorMap[x] + return ok +} + var _OceanColorValue = map[string]OceanColor{ - _OceanColorName[0:8]: 0, - _OceanColorName[8:12]: 1, - _OceanColorName[12:17]: 2, + _OceanColorName[0:8]: OceanColorCerulean, + _OceanColorName[8:12]: OceanColorBlue, + _OceanColorName[12:17]: OceanColorGreen, } -// ParseOceanColor attempts to convert a string to a OceanColor +// ParseOceanColor attempts to convert a string to a OceanColor. func ParseOceanColor(name string) (OceanColor, error) { if x, ok := _OceanColorValue[name]; ok { return x, nil } - return OceanColor(0), fmt.Errorf("%s is not a valid OceanColor", name) + return OceanColor(0), fmt.Errorf("%s is %w", name, ErrInvalidOceanColor) } func ParseOceanColorGlobbedExample() bool { @@ -57,3 +73,6 @@ func ParseOceanColorGlobbedExample2() bool { func ParseOceanColorExample() bool { return true } +func ParseOceanColorDescription() string { + return `OceanColor is an enumeration of ocean colors that are allowed.` +} diff --git a/example/user_template_test.go b/example/user_template_test.go index c206c292..14d363e3 100644 --- a/example/user_template_test.go +++ b/example/user_template_test.go @@ -1,3 +1,6 @@ +//go:build example +// +build example + package example import ( @@ -8,7 +11,16 @@ import ( func TestUserTemplateColor(t *testing.T) { assert.Equal(t, OceanColor(0), OceanColorCerulean) + assert.Equal(t, "OceanColor is an enumeration of ocean colors that are allowed.", ParseOceanColorDescription()) assert.Equal(t, true, ParseOceanColorExample()) assert.Equal(t, true, ParseOceanColorGlobbedExample()) assert.Equal(t, true, ParseOceanColorGlobbedExample2()) + + val, err := ParseOceanColor("Cerulean") + assert.NoError(t, err) + assert.Equal(t, "Cerulean", val.String()) + + assert.Equal(t, "OceanColor(99)", OceanColor(99).String()) + _, err = ParseOceanColor("-1") + assert.Error(t, err) } diff --git a/generator/.snapshots/Test118CustomPrefixExampleFile-1.18 b/generator/.snapshots/Test118CustomPrefixExampleFile-1.18 new file mode 100644 index 00000000..efb75716 --- /dev/null +++ b/generator/.snapshots/Test118CustomPrefixExampleFile-1.18 @@ -0,0 +1,290 @@ +([]string) (len=288) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=21) "\tjson \"encoding/json\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strconv\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// Custom_prefix_Create is a ChangeType of type Create.", + (string) (len=39) "\tCustom_prefix_Create ChangeType = iota", + (string) (len=56) "\t// Custom_prefix_Update is a ChangeType of type Update.", + (string) (len=21) "\tCustom_prefix_Update", + (string) (len=56) "\t// Custom_prefix_Delete is a ChangeType of type Delete.", + (string) (len=21) "\tCustom_prefix_Delete", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidChangeType = errors.New(\"not a valid ChangeType\")", + (string) "", + (string) (len=44) "const _ChangeTypeName = \"CreateUpdateDelete\"", + (string) "", + (string) (len=43) "var _ChangeTypeMap = map[ChangeType]string{", + (string) (len=44) "\tCustom_prefix_Create: _ChangeTypeName[0:6],", + (string) (len=45) "\tCustom_prefix_Update: _ChangeTypeName[6:12],", + (string) (len=46) "\tCustom_prefix_Delete: _ChangeTypeName[12:18],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x ChangeType) String() string {", + (string) (len=38) "\tif str, ok := _ChangeTypeMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"ChangeType(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x ChangeType) IsValid() bool {", + (string) (len=27) "\t_, ok := _ChangeTypeMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _ChangeTypeValue = map[string]ChangeType{", + (string) (len=63) "\t_ChangeTypeName[0:6]: Custom_prefix_Create,", + (string) (len=63) "\tstrings.ToLower(_ChangeTypeName[0:6]): Custom_prefix_Create,", + (string) (len=63) "\t_ChangeTypeName[6:12]: Custom_prefix_Update,", + (string) (len=63) "\tstrings.ToLower(_ChangeTypeName[6:12]): Custom_prefix_Update,", + (string) (len=63) "\t_ChangeTypeName[12:18]: Custom_prefix_Delete,", + (string) (len=63) "\tstrings.ToLower(_ChangeTypeName[12:18]): Custom_prefix_Delete,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseChangeType attempts to convert a string to a ChangeType.", + (string) (len=55) "func ParseChangeType(name string) (ChangeType, error) {", + (string) (len=41) "\tif x, ok := _ChangeTypeValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn ChangeType(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidChangeType)", + (string) (len=1) "}", + (string) "", + (string) (len=39) "func (x ChangeType) Ptr() *ChangeType {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x ChangeType) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *ChangeType) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseChangeType(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errChangeTypeNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *ChangeType) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = ChangeType(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseChangeType(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = ChangeType(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseChangeType(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = ChangeType(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=17) "\tcase ChangeType:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=18) "\tcase *ChangeType:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseChangeType(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = ChangeType(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x ChangeType) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *ChangeType) Set(val string) error {", + (string) (len=31) "\tv, err := ParseChangeType(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *ChangeType) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *ChangeType) Type() string {", + (string) (len=20) "\treturn \"ChangeType\"", + (string) (len=1) "}", + (string) "", + (string) (len=28) "type NullChangeType struct {", + (string) (len=22) "\tChangeType ChangeType", + (string) (len=16) "\tValid bool", + (string) (len=16) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=60) "func NewNullChangeType(val interface{}) (x NullChangeType) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=62) "func (x *NullChangeType) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=46) "\t\tx.ChangeType, x.Valid = ChangeType(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=31) "\terr = x.ChangeType.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=55) "func (x NullChangeType) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=32) "\treturn int64(x.ChangeType), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullChangeType to JSON.", + (string) (len=55) "func (n NullChangeType) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.ChangeType)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullChangeType from JSON.", + (string) (len=56) "func (n *NullChangeType) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=31) "type NullChangeTypeStr struct {", + (string) (len=15) "\tNullChangeType", + (string) (len=1) "}", + (string) "", + (string) (len=66) "func NewNullChangeTypeStr(val interface{}) (x NullChangeTypeStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x NullChangeTypeStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=34) "\treturn x.ChangeType.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullChangeType to JSON.", + (string) (len=58) "func (n NullChangeTypeStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.ChangeType)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullChangeType from JSON.", + (string) (len=59) "func (n *NullChangeTypeStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/generator-TestCustomPrefixExampleFile b/generator/.snapshots/Test118CustomPrefixExampleFile-og similarity index 62% rename from generator/.snapshots/generator-TestCustomPrefixExampleFile rename to generator/.snapshots/Test118CustomPrefixExampleFile-og index e1cf33db..5921a187 100644 --- a/generator/.snapshots/generator-TestCustomPrefixExampleFile +++ b/generator/.snapshots/Test118CustomPrefixExampleFile-og @@ -1,17 +1,19 @@ -([]string) (len=3052) { - (string) (len=28) "// Code generated by go-enum", - (string) (len=15) "// DO NOT EDIT!", +([]string) (len=4062) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", (string) "", (string) (len=17) "package generator", (string) "", (string) (len=8) "import (", (string) (len=22) "\t\"database/sql/driver\"", - (string) (len=16) "\t\"encoding/json\"", + (string) (len=21) "\tjson \"encoding/json\"", + (string) (len=9) "\t\"errors\"", (string) (len=6) "\t\"fmt\"", (string) (len=10) "\t\"strconv\"", (string) (len=10) "\t\"strings\"", - (string) "", - (string) (len=24) "\t\"github.com/pkg/errors\"", (string) (len=1) ")", (string) "", (string) (len=7) "const (", @@ -23,12 +25,14 @@ (string) (len=19) "\tCustom_prefix_Fish", (string) (len=1) ")", (string) "", + (string) (len=55) "var ErrInvalidAnimal = errors.New(\"not a valid Animal\")", + (string) "", (string) (len=32) "const _AnimalName = \"CatDogFish\"", (string) "", (string) (len=35) "var _AnimalMap = map[Animal]string{", - (string) (len=21) "\t0: _AnimalName[0:3],", - (string) (len=21) "\t1: _AnimalName[3:6],", - (string) (len=22) "\t2: _AnimalName[6:10],", + (string) (len=38) "\tCustom_prefix_Cat: _AnimalName[0:3],", + (string) (len=38) "\tCustom_prefix_Dog: _AnimalName[3:6],", + (string) (len=39) "\tCustom_prefix_Fish: _AnimalName[6:10],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -39,33 +43,40 @@ (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=37) "var _AnimalValue = map[string]Animal{", - (string) (len=39) "\t_AnimalName[0:3]: 0,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[0:3]): 0,", - (string) (len=39) "\t_AnimalName[3:6]: 1,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[3:6]): 1,", - (string) (len=39) "\t_AnimalName[6:10]: 2,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[6:10]): 2,", + (string) (len=55) "\t_AnimalName[0:3]: Custom_prefix_Cat,", + (string) (len=55) "\tstrings.ToLower(_AnimalName[0:3]): Custom_prefix_Cat,", + (string) (len=55) "\t_AnimalName[3:6]: Custom_prefix_Dog,", + (string) (len=55) "\tstrings.ToLower(_AnimalName[3:6]): Custom_prefix_Dog,", + (string) (len=56) "\t_AnimalName[6:10]: Custom_prefix_Fish,", + (string) (len=56) "\tstrings.ToLower(_AnimalName[6:10]): Custom_prefix_Fish,", (string) (len=1) "}", (string) "", - (string) (len=55) "// ParseAnimal attempts to convert a string to a Animal", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=63) "\treturn Animal(0), fmt.Errorf(\"%s is not a valid Animal\", name)", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", (string) (len=1) "}", (string) "", (string) (len=31) "func (x Animal) Ptr() *Animal {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=30) "\ttmp, err := ParseAnimal(name)", @@ -76,7 +87,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=93) "var _AnimalErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=92) "var errAnimalNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=54) "func (x *Animal) Scan(value interface{}) (err error) {", @@ -112,7 +123,7 @@ (string) (len=16) "\t\t*x = Animal(v)", (string) (len=14) "\tcase *Animal:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -121,34 +132,34 @@ (string) (len=16) "\t\t*x = Animal(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=16) "\t\t*x = Animal(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x, err = ParseAnimal(*v)", (string) (len=17) "\t\tif err != nil {", @@ -285,12 +296,14 @@ (string) (len=36) "\tCustom_prefix_AnotherLowerCaseStart", (string) (len=1) ")", (string) "", + (string) (len=53) "var ErrInvalidCases = errors.New(\"not a valid Cases\")", + (string) "", (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", (string) "", (string) (len=33) "var _CasesMap = map[Cases]string{", - (string) (len=21) "\t0: _CasesName[0:10],", - (string) (len=22) "\t1: _CasesName[10:22],", - (string) (len=22) "\t2: _CasesName[22:43],", + (string) (len=55) "\tCustom_prefix_Test_lower: _CasesName[0:10],", + (string) (len=56) "\tCustom_prefix_Test_capital: _CasesName[10:22],", + (string) (len=56) "\tCustom_prefix_AnotherLowerCaseStart: _CasesName[22:43],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -301,33 +314,40 @@ (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=35) "var _CasesValue = map[string]Cases{", - (string) (len=39) "\t_CasesName[0:10]: 0,", - (string) (len=39) "\tstrings.ToLower(_CasesName[0:10]): 0,", - (string) (len=39) "\t_CasesName[10:22]: 1,", - (string) (len=39) "\tstrings.ToLower(_CasesName[10:22]): 1,", - (string) (len=39) "\t_CasesName[22:43]: 2,", - (string) (len=39) "\tstrings.ToLower(_CasesName[22:43]): 2,", + (string) (len=62) "\t_CasesName[0:10]: Custom_prefix_Test_lower,", + (string) (len=62) "\tstrings.ToLower(_CasesName[0:10]): Custom_prefix_Test_lower,", + (string) (len=64) "\t_CasesName[10:22]: Custom_prefix_Test_capital,", + (string) (len=64) "\tstrings.ToLower(_CasesName[10:22]): Custom_prefix_Test_capital,", + (string) (len=73) "\t_CasesName[22:43]: Custom_prefix_AnotherLowerCaseStart,", + (string) (len=73) "\tstrings.ToLower(_CasesName[22:43]): Custom_prefix_AnotherLowerCaseStart,", (string) (len=1) "}", (string) "", - (string) (len=53) "// ParseCases attempts to convert a string to a Cases", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", (string) (len=45) "func ParseCases(name string) (Cases, error) {", (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=61) "\treturn Cases(0), fmt.Errorf(\"%s is not a valid Cases\", name)", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", (string) (len=1) "}", (string) "", (string) (len=29) "func (x Cases) Ptr() *Cases {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=29) "\ttmp, err := ParseCases(name)", @@ -338,7 +358,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=92) "var _CasesErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=91) "var errCasesNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=53) "func (x *Cases) Scan(value interface{}) (err error) {", @@ -374,7 +394,7 @@ (string) (len=15) "\t\t*x = Cases(v)", (string) (len=13) "\tcase *Cases:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -383,34 +403,34 @@ (string) (len=15) "\t\t*x = Cases(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\t*x = Cases(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=26) "\t\t*x, err = ParseCases(*v)", (string) (len=17) "\t\tif err != nil {", @@ -555,16 +575,18 @@ (string) (len=21) "\tCustom_prefix_Yellow", (string) (len=1) ")", (string) "", + (string) (len=53) "var ErrInvalidColor = errors.New(\"not a valid Color\")", + (string) "", (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", (string) "", (string) (len=33) "var _ColorMap = map[Color]string{", - (string) (len=21) "\t0: _ColorName[0:5],", - (string) (len=22) "\t1: _ColorName[5:10],", - (string) (len=23) "\t2: _ColorName[10:13],", - (string) (len=23) "\t3: _ColorName[13:18],", - (string) (len=23) "\t33: _ColorName[18:22],", - (string) (len=23) "\t34: _ColorName[22:26],", - (string) (len=23) "\t35: _ColorName[26:32],", + (string) (len=39) "\tCustom_prefix_Black: _ColorName[0:5],", + (string) (len=40) "\tCustom_prefix_White: _ColorName[5:10],", + (string) (len=41) "\tCustom_prefix_Red: _ColorName[10:13],", + (string) (len=41) "\tCustom_prefix_Green: _ColorName[13:18],", + (string) (len=41) "\tCustom_prefix_Blue: _ColorName[18:22],", + (string) (len=41) "\tCustom_prefix_Grey: _ColorName[22:26],", + (string) (len=41) "\tCustom_prefix_Yellow: _ColorName[26:32],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -575,41 +597,48 @@ (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=35) "var _ColorValue = map[string]Color{", - (string) (len=39) "\t_ColorName[0:5]: 0,", - (string) (len=39) "\tstrings.ToLower(_ColorName[0:5]): 0,", - (string) (len=39) "\t_ColorName[5:10]: 1,", - (string) (len=39) "\tstrings.ToLower(_ColorName[5:10]): 1,", - (string) (len=39) "\t_ColorName[10:13]: 2,", - (string) (len=39) "\tstrings.ToLower(_ColorName[10:13]): 2,", - (string) (len=39) "\t_ColorName[13:18]: 3,", - (string) (len=39) "\tstrings.ToLower(_ColorName[13:18]): 3,", - (string) (len=40) "\t_ColorName[18:22]: 33,", - (string) (len=40) "\tstrings.ToLower(_ColorName[18:22]): 33,", - (string) (len=40) "\t_ColorName[22:26]: 34,", - (string) (len=40) "\tstrings.ToLower(_ColorName[22:26]): 34,", - (string) (len=40) "\t_ColorName[26:32]: 35,", - (string) (len=40) "\tstrings.ToLower(_ColorName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseColor attempts to convert a string to a Color", + (string) (len=57) "\t_ColorName[0:5]: Custom_prefix_Black,", + (string) (len=57) "\tstrings.ToLower(_ColorName[0:5]): Custom_prefix_Black,", + (string) (len=57) "\t_ColorName[5:10]: Custom_prefix_White,", + (string) (len=57) "\tstrings.ToLower(_ColorName[5:10]): Custom_prefix_White,", + (string) (len=55) "\t_ColorName[10:13]: Custom_prefix_Red,", + (string) (len=55) "\tstrings.ToLower(_ColorName[10:13]): Custom_prefix_Red,", + (string) (len=57) "\t_ColorName[13:18]: Custom_prefix_Green,", + (string) (len=57) "\tstrings.ToLower(_ColorName[13:18]): Custom_prefix_Green,", + (string) (len=56) "\t_ColorName[18:22]: Custom_prefix_Blue,", + (string) (len=56) "\tstrings.ToLower(_ColorName[18:22]): Custom_prefix_Blue,", + (string) (len=56) "\t_ColorName[22:26]: Custom_prefix_Grey,", + (string) (len=56) "\tstrings.ToLower(_ColorName[22:26]): Custom_prefix_Grey,", + (string) (len=58) "\t_ColorName[26:32]: Custom_prefix_Yellow,", + (string) (len=58) "\tstrings.ToLower(_ColorName[26:32]): Custom_prefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", (string) (len=45) "func ParseColor(name string) (Color, error) {", (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=61) "\treturn Color(0), fmt.Errorf(\"%s is not a valid Color\", name)", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", (string) (len=1) "}", (string) "", (string) (len=29) "func (x Color) Ptr() *Color {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=29) "\ttmp, err := ParseColor(name)", @@ -620,7 +649,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=92) "var _ColorErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=91) "var errColorNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=53) "func (x *Color) Scan(value interface{}) (err error) {", @@ -656,7 +685,7 @@ (string) (len=15) "\t\t*x = Color(v)", (string) (len=13) "\tcase *Color:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -665,34 +694,34 @@ (string) (len=15) "\t\t*x = Color(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\t*x = Color(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=26) "\t\t*x, err = ParseColor(*v)", (string) (len=17) "\t\tif err != nil {", @@ -830,7 +859,7 @@ (string) (len=60) "\t// Custom_prefix_Green is a ColorWithComment of type Green.", (string) (len=20) "\tCustom_prefix_Green", (string) (len=58) "\t// Custom_prefix_Blue is a ColorWithComment of type Blue.", - (string) (len=23) "\t// Blue starts with 33", + (string) (len=24) "\t// Blue starts with 33.", (string) (len=48) "\tCustom_prefix_Blue ColorWithComment = iota + 29", (string) (len=58) "\t// Custom_prefix_Grey is a ColorWithComment of type Grey.", (string) (len=19) "\tCustom_prefix_Grey", @@ -838,16 +867,18 @@ (string) (len=21) "\tCustom_prefix_Yellow", (string) (len=1) ")", (string) "", + (string) (len=75) "var ErrInvalidColorWithComment = errors.New(\"not a valid ColorWithComment\")", + (string) "", (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", (string) "", (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", - (string) (len=32) "\t0: _ColorWithCommentName[0:5],", - (string) (len=33) "\t1: _ColorWithCommentName[5:10],", - (string) (len=34) "\t2: _ColorWithCommentName[10:13],", - (string) (len=34) "\t3: _ColorWithCommentName[13:18],", - (string) (len=34) "\t33: _ColorWithCommentName[18:22],", - (string) (len=34) "\t34: _ColorWithCommentName[22:26],", - (string) (len=34) "\t35: _ColorWithCommentName[26:32],", + (string) (len=50) "\tCustom_prefix_Black: _ColorWithCommentName[0:5],", + (string) (len=51) "\tCustom_prefix_White: _ColorWithCommentName[5:10],", + (string) (len=52) "\tCustom_prefix_Red: _ColorWithCommentName[10:13],", + (string) (len=52) "\tCustom_prefix_Green: _ColorWithCommentName[13:18],", + (string) (len=52) "\tCustom_prefix_Blue: _ColorWithCommentName[18:22],", + (string) (len=52) "\tCustom_prefix_Grey: _ColorWithCommentName[22:26],", + (string) (len=52) "\tCustom_prefix_Yellow: _ColorWithCommentName[26:32],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -858,41 +889,48 @@ (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", - (string) (len=50) "\t_ColorWithCommentName[0:5]: 0,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[0:5]): 0,", - (string) (len=50) "\t_ColorWithCommentName[5:10]: 1,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[5:10]): 1,", - (string) (len=50) "\t_ColorWithCommentName[10:13]: 2,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[10:13]): 2,", - (string) (len=50) "\t_ColorWithCommentName[13:18]: 3,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[13:18]): 3,", - (string) (len=51) "\t_ColorWithCommentName[18:22]: 33,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[18:22]): 33,", - (string) (len=51) "\t_ColorWithCommentName[22:26]: 34,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[22:26]): 34,", - (string) (len=51) "\t_ColorWithCommentName[26:32]: 35,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=75) "// ParseColorWithComment attempts to convert a string to a ColorWithComment", + (string) (len=68) "\t_ColorWithCommentName[0:5]: Custom_prefix_Black,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[0:5]): Custom_prefix_Black,", + (string) (len=68) "\t_ColorWithCommentName[5:10]: Custom_prefix_White,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[5:10]): Custom_prefix_White,", + (string) (len=66) "\t_ColorWithCommentName[10:13]: Custom_prefix_Red,", + (string) (len=66) "\tstrings.ToLower(_ColorWithCommentName[10:13]): Custom_prefix_Red,", + (string) (len=68) "\t_ColorWithCommentName[13:18]: Custom_prefix_Green,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[13:18]): Custom_prefix_Green,", + (string) (len=67) "\t_ColorWithCommentName[18:22]: Custom_prefix_Blue,", + (string) (len=67) "\tstrings.ToLower(_ColorWithCommentName[18:22]): Custom_prefix_Blue,", + (string) (len=67) "\t_ColorWithCommentName[22:26]: Custom_prefix_Grey,", + (string) (len=67) "\tstrings.ToLower(_ColorWithCommentName[22:26]): Custom_prefix_Grey,", + (string) (len=69) "\t_ColorWithCommentName[26:32]: Custom_prefix_Yellow,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[26:32]): Custom_prefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=83) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is not a valid ColorWithComment\", name)", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", (string) (len=1) "}", (string) "", (string) (len=51) "func (x ColorWithComment) Ptr() *ColorWithComment {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", @@ -903,7 +941,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=103) "var _ColorWithCommentErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=102) "var errColorWithCommentNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=64) "func (x *ColorWithComment) Scan(value interface{}) (err error) {", @@ -939,7 +977,7 @@ (string) (len=26) "\t\t*x = ColorWithComment(v)", (string) (len=24) "\tcase *ColorWithComment:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -948,34 +986,34 @@ (string) (len=26) "\t\t*x = ColorWithComment(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=26) "\t\t*x = ColorWithComment(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=37) "\t\t*x, err = ParseColorWithComment(*v)", (string) (len=17) "\t\tif err != nil {", @@ -1121,16 +1159,18 @@ (string) (len=21) "\tCustom_prefix_Yellow", (string) (len=1) ")", (string) "", + (string) (len=77) "var ErrInvalidColorWithComment2 = errors.New(\"not a valid ColorWithComment2\")", + (string) "", (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", (string) "", (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", - (string) (len=33) "\t0: _ColorWithComment2Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment2Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment2Name[10:13],", - (string) (len=35) "\t3: _ColorWithComment2Name[13:18],", - (string) (len=35) "\t33: _ColorWithComment2Name[18:22],", - (string) (len=35) "\t34: _ColorWithComment2Name[22:26],", - (string) (len=35) "\t35: _ColorWithComment2Name[26:32],", + (string) (len=51) "\tCustom_prefix_Black: _ColorWithComment2Name[0:5],", + (string) (len=52) "\tCustom_prefix_White: _ColorWithComment2Name[5:10],", + (string) (len=53) "\tCustom_prefix_Red: _ColorWithComment2Name[10:13],", + (string) (len=53) "\tCustom_prefix_Green: _ColorWithComment2Name[13:18],", + (string) (len=53) "\tCustom_prefix_Blue: _ColorWithComment2Name[18:22],", + (string) (len=53) "\tCustom_prefix_Grey: _ColorWithComment2Name[22:26],", + (string) (len=53) "\tCustom_prefix_Yellow: _ColorWithComment2Name[26:32],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1141,41 +1181,48 @@ (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", - (string) (len=51) "\t_ColorWithComment2Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment2Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment2Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): 2,", - (string) (len=51) "\t_ColorWithComment2Name[13:18]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): 3,", - (string) (len=52) "\t_ColorWithComment2Name[18:22]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): 33,", - (string) (len=52) "\t_ColorWithComment2Name[22:26]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): 34,", - (string) (len=52) "\t_ColorWithComment2Name[26:32]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2", + (string) (len=69) "\t_ColorWithComment2Name[0:5]: Custom_prefix_Black,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): Custom_prefix_Black,", + (string) (len=69) "\t_ColorWithComment2Name[5:10]: Custom_prefix_White,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): Custom_prefix_White,", + (string) (len=67) "\t_ColorWithComment2Name[10:13]: Custom_prefix_Red,", + (string) (len=67) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): Custom_prefix_Red,", + (string) (len=69) "\t_ColorWithComment2Name[13:18]: Custom_prefix_Green,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): Custom_prefix_Green,", + (string) (len=68) "\t_ColorWithComment2Name[18:22]: Custom_prefix_Blue,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): Custom_prefix_Blue,", + (string) (len=68) "\t_ColorWithComment2Name[22:26]: Custom_prefix_Grey,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): Custom_prefix_Grey,", + (string) (len=70) "\t_ColorWithComment2Name[26:32]: Custom_prefix_Yellow,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): Custom_prefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is not a valid ColorWithComment2\", name)", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", (string) (len=1) "}", (string) "", (string) (len=53) "func (x ColorWithComment2) Ptr() *ColorWithComment2 {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", @@ -1186,7 +1233,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=104) "var _ColorWithComment2ErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=103) "var errColorWithComment2NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=65) "func (x *ColorWithComment2) Scan(value interface{}) (err error) {", @@ -1222,7 +1269,7 @@ (string) (len=27) "\t\t*x = ColorWithComment2(v)", (string) (len=25) "\tcase *ColorWithComment2:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1231,34 +1278,34 @@ (string) (len=27) "\t\t*x = ColorWithComment2(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=27) "\t\t*x = ColorWithComment2(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=38) "\t\t*x, err = ParseColorWithComment2(*v)", (string) (len=17) "\t\tif err != nil {", @@ -1411,19 +1458,21 @@ (string) (len=28) "\tCustom_prefix_RedOrangeBlue", (string) (len=1) ")", (string) "", + (string) (len=77) "var ErrInvalidColorWithComment3 = errors.New(\"not a valid ColorWithComment3\")", + (string) "", (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", (string) "", (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", - (string) (len=33) "\t0: _ColorWithComment3Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment3Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment3Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment3Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment3Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment3Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment3Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment3Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment3Name[42:52],", - (string) (len=35) "\t39: _ColorWithComment3Name[52:67],", + (string) (len=58) "\tCustom_prefix_Black: _ColorWithComment3Name[0:5],", + (string) (len=59) "\tCustom_prefix_White: _ColorWithComment3Name[5:10],", + (string) (len=60) "\tCustom_prefix_Red: _ColorWithComment3Name[10:13],", + (string) (len=60) "\tCustom_prefix_Green: _ColorWithComment3Name[13:18],", + (string) (len=60) "\tCustom_prefix_Blue: _ColorWithComment3Name[18:22],", + (string) (len=60) "\tCustom_prefix_Grey: _ColorWithComment3Name[22:26],", + (string) (len=60) "\tCustom_prefix_Yellow: _ColorWithComment3Name[26:32],", + (string) (len=60) "\tCustom_prefix_BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=60) "\tCustom_prefix_RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=60) "\tCustom_prefix_RedOrangeBlue: _ColorWithComment3Name[52:67],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1434,47 +1483,54 @@ (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", - (string) (len=51) "\t_ColorWithComment3Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment3Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment3Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): 2,", - (string) (len=52) "\t_ColorWithComment3Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment3Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment3Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment3Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment3Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment3Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): 38,", - (string) (len=52) "\t_ColorWithComment3Name[52:67]: 39,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): 39,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3", + (string) (len=69) "\t_ColorWithComment3Name[0:5]: Custom_prefix_Black,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): Custom_prefix_Black,", + (string) (len=69) "\t_ColorWithComment3Name[5:10]: Custom_prefix_White,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): Custom_prefix_White,", + (string) (len=67) "\t_ColorWithComment3Name[10:13]: Custom_prefix_Red,", + (string) (len=67) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): Custom_prefix_Red,", + (string) (len=69) "\t_ColorWithComment3Name[13:18]: Custom_prefix_Green,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): Custom_prefix_Green,", + (string) (len=68) "\t_ColorWithComment3Name[18:22]: Custom_prefix_Blue,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): Custom_prefix_Blue,", + (string) (len=68) "\t_ColorWithComment3Name[22:26]: Custom_prefix_Grey,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): Custom_prefix_Grey,", + (string) (len=70) "\t_ColorWithComment3Name[26:32]: Custom_prefix_Yellow,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): Custom_prefix_Yellow,", + (string) (len=73) "\t_ColorWithComment3Name[32:42]: Custom_prefix_BlueGreen,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): Custom_prefix_BlueGreen,", + (string) (len=73) "\t_ColorWithComment3Name[42:52]: Custom_prefix_RedOrange,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): Custom_prefix_RedOrange,", + (string) (len=77) "\t_ColorWithComment3Name[52:67]: Custom_prefix_RedOrangeBlue,", + (string) (len=77) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): Custom_prefix_RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is not a valid ColorWithComment3\", name)", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", (string) (len=1) "}", (string) "", (string) (len=53) "func (x ColorWithComment3) Ptr() *ColorWithComment3 {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", @@ -1485,7 +1541,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=104) "var _ColorWithComment3ErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=103) "var errColorWithComment3NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=65) "func (x *ColorWithComment3) Scan(value interface{}) (err error) {", @@ -1521,7 +1577,7 @@ (string) (len=27) "\t\t*x = ColorWithComment3(v)", (string) (len=25) "\tcase *ColorWithComment3:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1530,34 +1586,34 @@ (string) (len=27) "\t\t*x = ColorWithComment3(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=27) "\t\t*x = ColorWithComment3(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=38) "\t\t*x, err = ParseColorWithComment3(*v)", (string) (len=17) "\t\tif err != nil {", @@ -1713,18 +1769,20 @@ (string) (len=24) "\tCustom_prefix_RedOrange", (string) (len=1) ")", (string) "", + (string) (len=77) "var ErrInvalidColorWithComment4 = errors.New(\"not a valid ColorWithComment4\")", + (string) "", (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", (string) "", (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", - (string) (len=33) "\t1: _ColorWithComment4Name[0:5],", - (string) (len=34) "\t2: _ColorWithComment4Name[5:10],", - (string) (len=35) "\t3: _ColorWithComment4Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment4Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment4Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment4Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment4Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment4Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment4Name[42:52],", + (string) (len=54) "\tCustom_prefix_Black: _ColorWithComment4Name[0:5],", + (string) (len=55) "\tCustom_prefix_White: _ColorWithComment4Name[5:10],", + (string) (len=56) "\tCustom_prefix_Red: _ColorWithComment4Name[10:13],", + (string) (len=56) "\tCustom_prefix_Green: _ColorWithComment4Name[13:18],", + (string) (len=56) "\tCustom_prefix_Blue: _ColorWithComment4Name[18:22],", + (string) (len=56) "\tCustom_prefix_Grey: _ColorWithComment4Name[22:26],", + (string) (len=56) "\tCustom_prefix_Yellow: _ColorWithComment4Name[26:32],", + (string) (len=56) "\tCustom_prefix_BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=56) "\tCustom_prefix_RedOrange: _ColorWithComment4Name[42:52],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1735,45 +1793,52 @@ (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", - (string) (len=51) "\t_ColorWithComment4Name[0:5]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): 1,", - (string) (len=51) "\t_ColorWithComment4Name[5:10]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): 2,", - (string) (len=51) "\t_ColorWithComment4Name[10:13]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): 3,", - (string) (len=52) "\t_ColorWithComment4Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment4Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment4Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment4Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment4Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment4Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): 38,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4", + (string) (len=69) "\t_ColorWithComment4Name[0:5]: Custom_prefix_Black,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): Custom_prefix_Black,", + (string) (len=69) "\t_ColorWithComment4Name[5:10]: Custom_prefix_White,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): Custom_prefix_White,", + (string) (len=67) "\t_ColorWithComment4Name[10:13]: Custom_prefix_Red,", + (string) (len=67) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): Custom_prefix_Red,", + (string) (len=69) "\t_ColorWithComment4Name[13:18]: Custom_prefix_Green,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): Custom_prefix_Green,", + (string) (len=68) "\t_ColorWithComment4Name[18:22]: Custom_prefix_Blue,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): Custom_prefix_Blue,", + (string) (len=68) "\t_ColorWithComment4Name[22:26]: Custom_prefix_Grey,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): Custom_prefix_Grey,", + (string) (len=70) "\t_ColorWithComment4Name[26:32]: Custom_prefix_Yellow,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): Custom_prefix_Yellow,", + (string) (len=73) "\t_ColorWithComment4Name[32:42]: Custom_prefix_BlueGreen,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): Custom_prefix_BlueGreen,", + (string) (len=73) "\t_ColorWithComment4Name[42:52]: Custom_prefix_RedOrange,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): Custom_prefix_RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is not a valid ColorWithComment4\", name)", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", (string) (len=1) "}", (string) "", (string) (len=53) "func (x ColorWithComment4) Ptr() *ColorWithComment4 {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", @@ -1784,7 +1849,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=104) "var _ColorWithComment4ErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=103) "var errColorWithComment4NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=65) "func (x *ColorWithComment4) Scan(value interface{}) (err error) {", @@ -1820,7 +1885,7 @@ (string) (len=27) "\t\t*x = ColorWithComment4(v)", (string) (len=25) "\tcase *ColorWithComment4:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1829,34 +1894,34 @@ (string) (len=27) "\t\t*x = ColorWithComment4(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=27) "\t\t*x = ColorWithComment4(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=38) "\t\t*x, err = ParseColorWithComment4(*v)", (string) (len=17) "\t\tif err != nil {", @@ -1985,6 +2050,337 @@ (string) (len=1) "}", (string) "", (string) (len=7) "const (", + (string) (len=57) "\t// Custom_prefix_Unknown is a Enum64bit of type Unknown.", + (string) (len=39) "\tCustom_prefix_Unknown Enum64bit = iota", + (string) (len=53) "\t// Custom_prefix_E2P15 is a Enum64bit of type E2P15.", + (string) (len=45) "\tCustom_prefix_E2P15 Enum64bit = iota + 32767", + (string) (len=53) "\t// Custom_prefix_E2P16 is a Enum64bit of type E2P16.", + (string) (len=45) "\tCustom_prefix_E2P16 Enum64bit = iota + 65534", + (string) (len=53) "\t// Custom_prefix_E2P17 is a Enum64bit of type E2P17.", + (string) (len=46) "\tCustom_prefix_E2P17 Enum64bit = iota + 131069", + (string) (len=53) "\t// Custom_prefix_E2P18 is a Enum64bit of type E2P18.", + (string) (len=46) "\tCustom_prefix_E2P18 Enum64bit = iota + 262140", + (string) (len=53) "\t// Custom_prefix_E2P19 is a Enum64bit of type E2P19.", + (string) (len=46) "\tCustom_prefix_E2P19 Enum64bit = iota + 524283", + (string) (len=53) "\t// Custom_prefix_E2P20 is a Enum64bit of type E2P20.", + (string) (len=47) "\tCustom_prefix_E2P20 Enum64bit = iota + 1048570", + (string) (len=53) "\t// Custom_prefix_E2P21 is a Enum64bit of type E2P21.", + (string) (len=47) "\tCustom_prefix_E2P21 Enum64bit = iota + 2097145", + (string) (len=53) "\t// Custom_prefix_E2P22 is a Enum64bit of type E2P22.", + (string) (len=48) "\tCustom_prefix_E2P22 Enum64bit = iota + 33554424", + (string) (len=53) "\t// Custom_prefix_E2P23 is a Enum64bit of type E2P23.", + (string) (len=48) "\tCustom_prefix_E2P23 Enum64bit = iota + 67108855", + (string) (len=53) "\t// Custom_prefix_E2P28 is a Enum64bit of type E2P28.", + (string) (len=49) "\tCustom_prefix_E2P28 Enum64bit = iota + 536870902", + (string) (len=53) "\t// Custom_prefix_E2P30 is a Enum64bit of type E2P30.", + (string) (len=50) "\tCustom_prefix_E2P30 Enum64bit = iota + 1073741813", + (string) (len=53) "\t// Custom_prefix_E2P31 is a Enum64bit of type E2P31.", + (string) (len=50) "\tCustom_prefix_E2P31 Enum64bit = iota + 2147483636", + (string) (len=53) "\t// Custom_prefix_E2P32 is a Enum64bit of type E2P32.", + (string) (len=50) "\tCustom_prefix_E2P32 Enum64bit = iota + 4294967283", + (string) (len=53) "\t// Custom_prefix_E2P33 is a Enum64bit of type E2P33.", + (string) (len=50) "\tCustom_prefix_E2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=61) "var ErrInvalidEnum64bit = errors.New(\"not a valid Enum64bit\")", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=44) "\tCustom_prefix_Unknown: _Enum64bitName[0:7],", + (string) (len=45) "\tCustom_prefix_E2P15: _Enum64bitName[7:12],", + (string) (len=46) "\tCustom_prefix_E2P16: _Enum64bitName[12:17],", + (string) (len=46) "\tCustom_prefix_E2P17: _Enum64bitName[17:22],", + (string) (len=46) "\tCustom_prefix_E2P18: _Enum64bitName[22:27],", + (string) (len=46) "\tCustom_prefix_E2P19: _Enum64bitName[27:32],", + (string) (len=46) "\tCustom_prefix_E2P20: _Enum64bitName[32:37],", + (string) (len=46) "\tCustom_prefix_E2P21: _Enum64bitName[37:42],", + (string) (len=46) "\tCustom_prefix_E2P22: _Enum64bitName[42:47],", + (string) (len=46) "\tCustom_prefix_E2P23: _Enum64bitName[47:52],", + (string) (len=46) "\tCustom_prefix_E2P28: _Enum64bitName[52:57],", + (string) (len=46) "\tCustom_prefix_E2P30: _Enum64bitName[57:62],", + (string) (len=46) "\tCustom_prefix_E2P31: _Enum64bitName[62:67],", + (string) (len=46) "\tCustom_prefix_E2P32: _Enum64bitName[67:72],", + (string) (len=46) "\tCustom_prefix_E2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=63) "\t_Enum64bitName[0:7]: Custom_prefix_Unknown,", + (string) (len=63) "\tstrings.ToLower(_Enum64bitName[0:7]): Custom_prefix_Unknown,", + (string) (len=61) "\t_Enum64bitName[7:12]: Custom_prefix_E2P15,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[7:12]): Custom_prefix_E2P15,", + (string) (len=61) "\t_Enum64bitName[12:17]: Custom_prefix_E2P16,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[12:17]): Custom_prefix_E2P16,", + (string) (len=61) "\t_Enum64bitName[17:22]: Custom_prefix_E2P17,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[17:22]): Custom_prefix_E2P17,", + (string) (len=61) "\t_Enum64bitName[22:27]: Custom_prefix_E2P18,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[22:27]): Custom_prefix_E2P18,", + (string) (len=61) "\t_Enum64bitName[27:32]: Custom_prefix_E2P19,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[27:32]): Custom_prefix_E2P19,", + (string) (len=61) "\t_Enum64bitName[32:37]: Custom_prefix_E2P20,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[32:37]): Custom_prefix_E2P20,", + (string) (len=61) "\t_Enum64bitName[37:42]: Custom_prefix_E2P21,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[37:42]): Custom_prefix_E2P21,", + (string) (len=61) "\t_Enum64bitName[42:47]: Custom_prefix_E2P22,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[42:47]): Custom_prefix_E2P22,", + (string) (len=61) "\t_Enum64bitName[47:52]: Custom_prefix_E2P23,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[47:52]): Custom_prefix_E2P23,", + (string) (len=61) "\t_Enum64bitName[52:57]: Custom_prefix_E2P28,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[52:57]): Custom_prefix_E2P28,", + (string) (len=61) "\t_Enum64bitName[57:62]: Custom_prefix_E2P30,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[57:62]): Custom_prefix_E2P30,", + (string) (len=61) "\t_Enum64bitName[62:67]: Custom_prefix_E2P31,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[62:67]): Custom_prefix_E2P31,", + (string) (len=61) "\t_Enum64bitName[67:72]: Custom_prefix_E2P32,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[67:72]): Custom_prefix_E2P32,", + (string) (len=61) "\t_Enum64bitName[72:77]: Custom_prefix_E2P33,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[72:77]): Custom_prefix_E2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=37) "func (x Enum64bit) Ptr() *Enum64bit {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=95) "var errEnum64bitNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *Enum64bit) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=19) "\t\t*x = Enum64bit(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase string:", + (string) (len=29) "\t\t*x, err = ParseEnum64bit(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=33) "\t\t\t\t*x, err = Enum64bit(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=37) "\t\t*x, err = ParseEnum64bit(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=33) "\t\t\t\t*x, err = Enum64bit(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=16) "\tcase Enum64bit:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=17) "\tcase *Enum64bit:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=30) "\t\t*x, err = ParseEnum64bit(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=33) "\t\t\t\t*x, err = Enum64bit(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x Enum64bit) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=43) "func (x *Enum64bit) Set(val string) error {", + (string) (len=30) "\tv, err := ParseEnum64bit(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=39) "func (x *Enum64bit) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=35) "func (x *Enum64bit) Type() string {", + (string) (len=19) "\treturn \"Enum64bit\"", + (string) (len=1) "}", + (string) "", + (string) (len=27) "type NullEnum64bit struct {", + (string) (len=20) "\tEnum64bit Enum64bit", + (string) (len=15) "\tValid bool", + (string) (len=15) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=58) "func NewNullEnum64bit(val interface{}) (x NullEnum64bit) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=61) "func (x *NullEnum64bit) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=44) "\t\tx.Enum64bit, x.Valid = Enum64bit(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=30) "\terr = x.Enum64bit.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=54) "func (x NullEnum64bit) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=31) "\treturn int64(x.Enum64bit), nil", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// MarshalJSON correctly serializes a NullEnum64bit to JSON.", + (string) (len=54) "func (n NullEnum64bit) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=34) "\t\treturn json.Marshal(n.Enum64bit)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// UnmarshalJSON correctly deserializes a NullEnum64bit from JSON.", + (string) (len=55) "func (n *NullEnum64bit) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=30) "type NullEnum64bitStr struct {", + (string) (len=14) "\tNullEnum64bit", + (string) (len=1) "}", + (string) "", + (string) (len=64) "func NewNullEnum64bitStr(val interface{}) (x NullEnum64bitStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x NullEnum64bitStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=33) "\treturn x.Enum64bit.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// MarshalJSON correctly serializes a NullEnum64bit to JSON.", + (string) (len=57) "func (n NullEnum64bitStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=34) "\t\treturn json.Marshal(n.Enum64bit)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// UnmarshalJSON correctly deserializes a NullEnum64bit from JSON.", + (string) (len=58) "func (n *NullEnum64bitStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", (string) (len=51) "\t// Custom_prefix_Toyota is a Model of type Toyota.", (string) (len=34) "\tCustom_prefix_Toyota Model = iota", (string) (len=18) "\t// Skipped value.", @@ -1997,12 +2393,14 @@ (string) (len=19) "\tCustom_prefix_Ford", (string) (len=1) ")", (string) "", + (string) (len=53) "var ErrInvalidModel = errors.New(\"not a valid Model\")", + (string) "", (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", (string) "", (string) (len=33) "var _ModelMap = map[Model]string{", - (string) (len=20) "\t0: _ModelName[0:6],", - (string) (len=21) "\t2: _ModelName[6:11],", - (string) (len=22) "\t4: _ModelName[11:15],", + (string) (len=39) "\tCustom_prefix_Toyota: _ModelName[0:6],", + (string) (len=40) "\tCustom_prefix_Chevy: _ModelName[6:11],", + (string) (len=41) "\tCustom_prefix_Ford: _ModelName[11:15],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -2013,33 +2411,40 @@ (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=35) "var _ModelValue = map[string]Model{", - (string) (len=39) "\t_ModelName[0:6]: 0,", - (string) (len=39) "\tstrings.ToLower(_ModelName[0:6]): 0,", - (string) (len=39) "\t_ModelName[6:11]: 2,", - (string) (len=39) "\tstrings.ToLower(_ModelName[6:11]): 2,", - (string) (len=39) "\t_ModelName[11:15]: 4,", - (string) (len=39) "\tstrings.ToLower(_ModelName[11:15]): 4,", + (string) (len=58) "\t_ModelName[0:6]: Custom_prefix_Toyota,", + (string) (len=58) "\tstrings.ToLower(_ModelName[0:6]): Custom_prefix_Toyota,", + (string) (len=57) "\t_ModelName[6:11]: Custom_prefix_Chevy,", + (string) (len=57) "\tstrings.ToLower(_ModelName[6:11]): Custom_prefix_Chevy,", + (string) (len=56) "\t_ModelName[11:15]: Custom_prefix_Ford,", + (string) (len=56) "\tstrings.ToLower(_ModelName[11:15]): Custom_prefix_Ford,", (string) (len=1) "}", (string) "", - (string) (len=53) "// ParseModel attempts to convert a string to a Model", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", (string) (len=45) "func ParseModel(name string) (Model, error) {", (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=61) "\treturn Model(0), fmt.Errorf(\"%s is not a valid Model\", name)", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", (string) (len=1) "}", (string) "", (string) (len=29) "func (x Model) Ptr() *Model {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=29) "\ttmp, err := ParseModel(name)", @@ -2050,7 +2455,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=92) "var _ModelErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=91) "var errModelNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=53) "func (x *Model) Scan(value interface{}) (err error) {", @@ -2086,7 +2491,7 @@ (string) (len=15) "\t\t*x = Model(v)", (string) (len=13) "\tcase *Model:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -2095,34 +2500,34 @@ (string) (len=15) "\t\t*x = Model(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\t*x = Model(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=26) "\t\t*x, err = ParseModel(*v)", (string) (len=17) "\t\tif err != nil {", @@ -2251,80 +2656,69 @@ (string) (len=1) "}", (string) "", (string) (len=7) "const (", - (string) (len=65) "\t// Custom_prefix_TestHyphen is a Sanitizing of type Test-Hyphen.", - (string) (len=43) "\tCustom_prefix_TestHyphen Sanitizing = iota", - (string) (len=67) "\t// Custom_prefix_HyphenStart is a Sanitizing of type -HyphenStart.", - (string) (len=26) "\tCustom_prefix_HyphenStart", - (string) (len=76) "\t// Custom_prefix__underscoreFirst is a Sanitizing of type _underscoreFirst.", - (string) (len=31) "\tCustom_prefix__underscoreFirst", - (string) (len=68) "\t// Custom_prefix_0numberFirst is a Sanitizing of type 0numberFirst.", - (string) (len=27) "\tCustom_prefix_0numberFirst", - (string) (len=64) "\t// Custom_prefix_123456789a is a Sanitizing of type 123456789a.", - (string) (len=25) "\tCustom_prefix_123456789a", - (string) (len=65) "\t// Custom_prefix_123123Asdf is a Sanitizing of type 123123-Asdf.", - (string) (len=25) "\tCustom_prefix_123123Asdf", - (string) (len=70) "\t// Custom_prefix_EndingHyphen is a Sanitizing of type Ending-Hyphen-.", - (string) (len=27) "\tCustom_prefix_EndingHyphen", + (string) (len=66) "\t// Custom_prefix_Продам is a NonASCII of type Продам.", + (string) (len=50) "\tCustom_prefix_Продам NonASCII = iota + 1114", + (string) (len=54) "\t// Custom_prefix_車庫 is a NonASCII of type 車庫.", + (string) (len=43) "\tCustom_prefix_車庫 NonASCII = iota + 299", + (string) (len=58) "\t// Custom_prefix_Էժան is a NonASCII of type Էժան.", + (string) (len=44) "\tCustom_prefix_Էժան NonASCII = iota + -1", (string) (len=1) ")", (string) "", - (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) (len=59) "var ErrInvalidNonASCII = errors.New(\"not a valid NonASCII\")", (string) "", - (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", - (string) (len=26) "\t0: _SanitizingName[0:11],", - (string) (len=27) "\t1: _SanitizingName[11:23],", - (string) (len=27) "\t2: _SanitizingName[23:39],", - (string) (len=27) "\t3: _SanitizingName[39:51],", - (string) (len=27) "\t4: _SanitizingName[51:61],", - (string) (len=27) "\t5: _SanitizingName[61:72],", - (string) (len=27) "\t6: _SanitizingName[72:86],", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=49) "\tCustom_prefix_Продам: _NonASCIIName[0:12],", + (string) (len=48) "\tCustom_prefix_車庫: _NonASCIIName[12:18],", + (string) (len=48) "\tCustom_prefix_Էժան: _NonASCIIName[18:26],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", - (string) (len=37) "func (x Sanitizing) String() string {", - (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", (string) (len=12) "\t\treturn str", (string) (len=2) "\t}", - (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", (string) (len=1) "}", (string) "", - (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", - (string) (len=44) "\t_SanitizingName[0:11]: 0,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[0:11]): 0,", - (string) (len=44) "\t_SanitizingName[11:23]: 1,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[11:23]): 1,", - (string) (len=44) "\t_SanitizingName[23:39]: 2,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[23:39]): 2,", - (string) (len=44) "\t_SanitizingName[39:51]: 3,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[39:51]): 3,", - (string) (len=44) "\t_SanitizingName[51:61]: 4,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[51:61]): 4,", - (string) (len=44) "\t_SanitizingName[61:72]: 5,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[61:72]): 5,", - (string) (len=44) "\t_SanitizingName[72:86]: 6,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[72:86]): 6,", - (string) (len=1) "}", - (string) "", - (string) (len=63) "// ParseSanitizing attempts to convert a string to a Sanitizing", - (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", - (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=67) "\t_NonASCIIName[0:12]: Custom_prefix_Продам,", + (string) (len=67) "\tstrings.ToLower(_NonASCIIName[0:12]): Custom_prefix_Продам,", + (string) (len=61) "\t_NonASCIIName[12:18]: Custom_prefix_車庫,", + (string) (len=61) "\tstrings.ToLower(_NonASCIIName[12:18]): Custom_prefix_車庫,", + (string) (len=63) "\t_NonASCIIName[18:26]: Custom_prefix_Էժան,", + (string) (len=63) "\tstrings.ToLower(_NonASCIIName[18:26]): Custom_prefix_Էժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=71) "\treturn Sanitizing(0), fmt.Errorf(\"%s is not a valid Sanitizing\", name)", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", (string) (len=1) "}", (string) "", - (string) (len=39) "func (x Sanitizing) Ptr() *Sanitizing {", + (string) (len=35) "func (x NonASCII) Ptr() *NonASCII {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", - (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", (string) (len=16) "\tif err != nil {", (string) (len=12) "\t\treturn err", (string) (len=2) "\t}", @@ -2332,12 +2726,12 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=97) "var _SanitizingErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=94) "var errNonASCIINilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", - (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", + (string) (len=56) "func (x *NonASCII) Scan(value interface{}) (err error) {", (string) (len=18) "\tif value == nil {", - (string) (len=20) "\t\t*x = Sanitizing(0)", + (string) (len=18) "\t\t*x = NonASCII(0)", (string) (len=8) "\t\treturn", (string) (len=2) "\t}", (string) "", @@ -2345,72 +2739,72 @@ (string) (len=61) "\t// driver.Value values at the top of the list for expediency", (string) (len=27) "\tswitch v := value.(type) {", (string) (len=12) "\tcase int64:", - (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\t\t*x = NonASCII(v)", (string) (len=13) "\tcase string:", - (string) (len=30) "\t\t*x, err = ParseSanitizing(v)", + (string) (len=28) "\t\t*x, err = ParseNonASCII(v)", (string) (len=17) "\t\tif err != nil {", (string) (len=47) "\t\t\t// try parsing the integer value as a string", (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", - (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=32) "\t\t\t\t*x, err = NonASCII(val), nil", (string) (len=4) "\t\t\t}", (string) (len=3) "\t\t}", (string) (len=13) "\tcase []byte:", - (string) (len=38) "\t\t*x, err = ParseSanitizing(string(v))", + (string) (len=36) "\t\t*x, err = ParseNonASCII(string(v))", (string) (len=17) "\t\tif err != nil {", (string) (len=47) "\t\t\t// try parsing the integer value as a string", (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", - (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=32) "\t\t\t\t*x, err = NonASCII(val), nil", (string) (len=4) "\t\t\t}", (string) (len=3) "\t\t}", - (string) (len=17) "\tcase Sanitizing:", + (string) (len=15) "\tcase NonASCII:", (string) (len=8) "\t\t*x = v", (string) (len=10) "\tcase int:", - (string) (len=20) "\t\t*x = Sanitizing(v)", - (string) (len=18) "\tcase *Sanitizing:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=16) "\tcase *NonASCII:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", - (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\t\t*x = NonASCII(v)", (string) (len=13) "\tcase uint64:", - (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\t\t*x = NonASCII(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", (string) (len=3) "\t\t}", - (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=19) "\t\t*x = NonASCII(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", (string) (len=3) "\t\t}", - (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=19) "\t\t*x = NonASCII(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", - (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\t\t*x = NonASCII(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", (string) (len=3) "\t\t}", - (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=19) "\t\t*x = NonASCII(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", (string) (len=3) "\t\t}", - (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=19) "\t\t*x = NonASCII(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", (string) (len=3) "\t\t}", - (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=19) "\t\t*x = NonASCII(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", (string) (len=3) "\t\t}", - (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", + (string) (len=29) "\t\t*x, err = ParseNonASCII(*v)", (string) (len=17) "\t\tif err != nil {", (string) (len=47) "\t\t\t// try parsing the integer value as a string", (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", - (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=32) "\t\t\t\t*x, err = NonASCII(val), nil", (string) (len=4) "\t\t\t}", (string) (len=3) "\t\t}", (string) (len=2) "\t}", @@ -2419,58 +2813,349 @@ (string) (len=1) "}", (string) "", (string) (len=48) "// Value implements the driver Valuer interface.", - (string) (len=51) "func (x Sanitizing) Value() (driver.Value, error) {", + (string) (len=49) "func (x NonASCII) Value() (driver.Value, error) {", (string) (len=23) "\treturn x.String(), nil", (string) (len=1) "}", (string) "", (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=44) "func (x *Sanitizing) Set(val string) error {", - (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=42) "func (x *NonASCII) Set(val string) error {", + (string) (len=29) "\tv, err := ParseNonASCII(val)", (string) (len=7) "\t*x = v", (string) (len=11) "\treturn err", (string) (len=1) "}", (string) "", (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=38) "func (x *NonASCII) Get() interface{} {", (string) (len=10) "\treturn *x", (string) (len=1) "}", (string) "", (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=36) "func (x *Sanitizing) Type() string {", - (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=34) "func (x *NonASCII) Type() string {", + (string) (len=18) "\treturn \"NonASCII\"", (string) (len=1) "}", (string) "", - (string) (len=28) "type NullSanitizing struct {", - (string) (len=22) "\tSanitizing Sanitizing", - (string) (len=16) "\tValid bool", - (string) (len=16) "\tSet bool", + (string) (len=26) "type NullNonASCII struct {", + (string) (len=18) "\tNonASCII NonASCII", + (string) (len=14) "\tValid bool", + (string) (len=14) "\tSet bool", (string) (len=1) "}", (string) "", - (string) (len=60) "func NewNullSanitizing(val interface{}) (x NullSanitizing) {", + (string) (len=56) "func NewNullNonASCII(val interface{}) (x NullNonASCII) {", (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", (string) (len=7) "\treturn", (string) (len=1) "}", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", - (string) (len=62) "func (x *NullSanitizing) Scan(value interface{}) (err error) {", + (string) (len=60) "func (x *NullNonASCII) Scan(value interface{}) (err error) {", (string) (len=13) "\tx.Set = true", (string) (len=18) "\tif value == nil {", - (string) (len=46) "\t\tx.Sanitizing, x.Valid = Sanitizing(0), false", + (string) (len=42) "\t\tx.NonASCII, x.Valid = NonASCII(0), false", (string) (len=8) "\t\treturn", (string) (len=2) "\t}", (string) "", - (string) (len=31) "\terr = x.Sanitizing.Scan(value)", + (string) (len=29) "\terr = x.NonASCII.Scan(value)", (string) (len=23) "\tx.Valid = (err == nil)", (string) (len=7) "\treturn", (string) (len=1) "}", (string) "", (string) (len=48) "// Value implements the driver Valuer interface.", - (string) (len=55) "func (x NullSanitizing) Value() (driver.Value, error) {", + (string) (len=53) "func (x NullNonASCII) Value() (driver.Value, error) {", (string) (len=14) "\tif !x.Valid {", (string) (len=17) "\t\treturn nil, nil", (string) (len=2) "\t}", (string) (len=46) "\t// driver.Value accepts int64 for int values.", - (string) (len=32) "\treturn int64(x.Sanitizing), nil", + (string) (len=30) "\treturn int64(x.NonASCII), nil", + (string) (len=1) "}", + (string) "", + (string) (len=59) "// MarshalJSON correctly serializes a NullNonASCII to JSON.", + (string) (len=53) "func (n NullNonASCII) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=33) "\t\treturn json.Marshal(n.NonASCII)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=65) "// UnmarshalJSON correctly deserializes a NullNonASCII from JSON.", + (string) (len=54) "func (n *NullNonASCII) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=29) "type NullNonASCIIStr struct {", + (string) (len=13) "\tNullNonASCII", + (string) (len=1) "}", + (string) "", + (string) (len=62) "func NewNullNonASCIIStr(val interface{}) (x NullNonASCIIStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=56) "func (x NullNonASCIIStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=32) "\treturn x.NonASCII.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=59) "// MarshalJSON correctly serializes a NullNonASCII to JSON.", + (string) (len=56) "func (n NullNonASCIIStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=33) "\t\treturn json.Marshal(n.NonASCII)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=65) "// UnmarshalJSON correctly deserializes a NullNonASCII from JSON.", + (string) (len=57) "func (n *NullNonASCIIStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=65) "\t// Custom_prefix_TestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=43) "\tCustom_prefix_TestHyphen Sanitizing = iota", + (string) (len=67) "\t// Custom_prefix_HyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=26) "\tCustom_prefix_HyphenStart", + (string) (len=76) "\t// Custom_prefix__UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=31) "\tCustom_prefix__UnderscoreFirst", + (string) (len=68) "\t// Custom_prefix_0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=27) "\tCustom_prefix_0NumberFirst", + (string) (len=64) "\t// Custom_prefix_123456789A is a Sanitizing of type 123456789A.", + (string) (len=25) "\tCustom_prefix_123456789A", + (string) (len=65) "\t// Custom_prefix_123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=25) "\tCustom_prefix_123123Asdf", + (string) (len=70) "\t// Custom_prefix_EndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=27) "\tCustom_prefix_EndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidSanitizing = errors.New(\"not a valid Sanitizing\")", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=55) "\tCustom_prefix_TestHyphen: _SanitizingName[0:11],", + (string) (len=56) "\tCustom_prefix_HyphenStart: _SanitizingName[11:23],", + (string) (len=56) "\tCustom_prefix__UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=56) "\tCustom_prefix_0NumberFirst: _SanitizingName[39:51],", + (string) (len=56) "\tCustom_prefix_123456789A: _SanitizingName[51:61],", + (string) (len=56) "\tCustom_prefix_123123Asdf: _SanitizingName[61:72],", + (string) (len=56) "\tCustom_prefix_EndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=67) "\t_SanitizingName[0:11]: Custom_prefix_TestHyphen,", + (string) (len=67) "\tstrings.ToLower(_SanitizingName[0:11]): Custom_prefix_TestHyphen,", + (string) (len=68) "\t_SanitizingName[11:23]: Custom_prefix_HyphenStart,", + (string) (len=68) "\tstrings.ToLower(_SanitizingName[11:23]): Custom_prefix_HyphenStart,", + (string) (len=73) "\t_SanitizingName[23:39]: Custom_prefix__UnderscoreFirst,", + (string) (len=73) "\tstrings.ToLower(_SanitizingName[23:39]): Custom_prefix__UnderscoreFirst,", + (string) (len=69) "\t_SanitizingName[39:51]: Custom_prefix_0NumberFirst,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[39:51]): Custom_prefix_0NumberFirst,", + (string) (len=67) "\t_SanitizingName[51:61]: Custom_prefix_123456789A,", + (string) (len=67) "\tstrings.ToLower(_SanitizingName[51:61]): Custom_prefix_123456789A,", + (string) (len=67) "\t_SanitizingName[61:72]: Custom_prefix_123123Asdf,", + (string) (len=67) "\tstrings.ToLower(_SanitizingName[61:72]): Custom_prefix_123123Asdf,", + (string) (len=69) "\t_SanitizingName[72:86]: Custom_prefix_EndingHyphen,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[72:86]): Custom_prefix_EndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=39) "func (x Sanitizing) Ptr() *Sanitizing {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errSanitizingNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = Sanitizing(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseSanitizing(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseSanitizing(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=17) "\tcase Sanitizing:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\tcase *Sanitizing:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x Sanitizing) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *Sanitizing) Set(val string) error {", + (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *Sanitizing) Type() string {", + (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=1) "}", + (string) "", + (string) (len=28) "type NullSanitizing struct {", + (string) (len=22) "\tSanitizing Sanitizing", + (string) (len=16) "\tValid bool", + (string) (len=16) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=60) "func NewNullSanitizing(val interface{}) (x NullSanitizing) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=62) "func (x *NullSanitizing) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=46) "\t\tx.Sanitizing, x.Valid = Sanitizing(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=31) "\terr = x.Sanitizing.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=55) "func (x NullSanitizing) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=32) "\treturn int64(x.Sanitizing), nil", (string) (len=1) "}", (string) "", (string) (len=61) "// MarshalJSON correctly serializes a NullSanitizing to JSON.", @@ -2541,12 +3226,14 @@ (string) (len=21) "\tCustom_prefix_MtnDew", (string) (len=1) ")", (string) "", + (string) (len=51) "var ErrInvalidSoda = errors.New(\"not a valid Soda\")", + (string) "", (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", (string) "", (string) (len=31) "var _SodaMap = map[Soda]string{", - (string) (len=19) "\t0: _SodaName[0:4],", - (string) (len=19) "\t1: _SodaName[4:9],", - (string) (len=20) "\t2: _SodaName[9:15],", + (string) (len=38) "\tCustom_prefix_Coke: _SodaName[0:4],", + (string) (len=38) "\tCustom_prefix_Pepsi: _SodaName[4:9],", + (string) (len=39) "\tCustom_prefix_MtnDew: _SodaName[9:15],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -2557,33 +3244,40 @@ (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=33) "var _SodaValue = map[string]Soda{", - (string) (len=37) "\t_SodaName[0:4]: 0,", - (string) (len=37) "\tstrings.ToLower(_SodaName[0:4]): 0,", - (string) (len=37) "\t_SodaName[4:9]: 1,", - (string) (len=37) "\tstrings.ToLower(_SodaName[4:9]): 1,", - (string) (len=37) "\t_SodaName[9:15]: 2,", - (string) (len=37) "\tstrings.ToLower(_SodaName[9:15]): 2,", + (string) (len=54) "\t_SodaName[0:4]: Custom_prefix_Coke,", + (string) (len=54) "\tstrings.ToLower(_SodaName[0:4]): Custom_prefix_Coke,", + (string) (len=55) "\t_SodaName[4:9]: Custom_prefix_Pepsi,", + (string) (len=55) "\tstrings.ToLower(_SodaName[4:9]): Custom_prefix_Pepsi,", + (string) (len=56) "\t_SodaName[9:15]: Custom_prefix_MtnDew,", + (string) (len=56) "\tstrings.ToLower(_SodaName[9:15]): Custom_prefix_MtnDew,", (string) (len=1) "}", (string) "", - (string) (len=51) "// ParseSoda attempts to convert a string to a Soda", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", (string) (len=43) "func ParseSoda(name string) (Soda, error) {", (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=59) "\treturn Soda(0), fmt.Errorf(\"%s is not a valid Soda\", name)", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", (string) (len=1) "}", (string) "", (string) (len=27) "func (x Soda) Ptr() *Soda {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=28) "\ttmp, err := ParseSoda(name)", @@ -2594,7 +3288,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=91) "var _SodaErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=90) "var errSodaNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=52) "func (x *Soda) Scan(value interface{}) (err error) {", @@ -2630,7 +3324,7 @@ (string) (len=14) "\t\t*x = Soda(v)", (string) (len=12) "\tcase *Soda:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -2639,34 +3333,34 @@ (string) (len=14) "\t\t*x = Soda(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=14) "\t\t*x = Soda(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=25) "\t\t*x, err = ParseSoda(*v)", (string) (len=17) "\t\tif err != nil {", @@ -2801,11 +3495,13 @@ (string) (len=22) "\tCustom_prefix_NextNum", (string) (len=1) ")", (string) "", + (string) (len=67) "var ErrInvalidStartNotZero = errors.New(\"not a valid StartNotZero\")", + (string) "", (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", (string) "", (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", - (string) (len=29) "\t23: _StartNotZeroName[0:12],", - (string) (len=30) "\t24: _StartNotZeroName[12:19],", + (string) (len=53) "\tCustom_prefix_StartWithNum: _StartNotZeroName[0:12],", + (string) (len=54) "\tCustom_prefix_NextNum: _StartNotZeroName[12:19],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -2816,31 +3512,38 @@ (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", - (string) (len=47) "\t_StartNotZeroName[0:12]: 23,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[0:12]): 23,", - (string) (len=47) "\t_StartNotZeroName[12:19]: 24,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[12:19]): 24,", + (string) (len=71) "\t_StartNotZeroName[0:12]: Custom_prefix_StartWithNum,", + (string) (len=71) "\tstrings.ToLower(_StartNotZeroName[0:12]): Custom_prefix_StartWithNum,", + (string) (len=66) "\t_StartNotZeroName[12:19]: Custom_prefix_NextNum,", + (string) (len=66) "\tstrings.ToLower(_StartNotZeroName[12:19]): Custom_prefix_NextNum,", (string) (len=1) "}", (string) "", - (string) (len=67) "// ParseStartNotZero attempts to convert a string to a StartNotZero", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=75) "\treturn StartNotZero(0), fmt.Errorf(\"%s is not a valid StartNotZero\", name)", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", (string) (len=1) "}", (string) "", (string) (len=43) "func (x StartNotZero) Ptr() *StartNotZero {", (string) (len=10) "\treturn &x", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", @@ -2851,7 +3554,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=99) "var _StartNotZeroErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=98) "var errStartNotZeroNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=60) "func (x *StartNotZero) Scan(value interface{}) (err error) {", @@ -2887,7 +3590,7 @@ (string) (len=22) "\t\t*x = StartNotZero(v)", (string) (len=20) "\tcase *StartNotZero:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -2896,34 +3599,34 @@ (string) (len=22) "\t\t*x = StartNotZero(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=22) "\t\t*x = StartNotZero(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=33) "\t\t*x, err = ParseStartNotZero(*v)", (string) (len=17) "\t\tif err != nil {", @@ -3050,5 +3753,312 @@ (string) (len=16) "\terr = n.Scan(x)", (string) (len=11) "\treturn err", (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// Custom_prefix_Random is a StringEnum of type random.", + (string) (len=43) "\tCustom_prefix_Random StringEnum = \"random\"", + (string) (len=56) "\t// Custom_prefix_Values is a StringEnum of type values.", + (string) (len=43) "\tCustom_prefix_Values StringEnum = \"values\"", + (string) (len=52) "\t// Custom_prefix_Here is a StringEnum of type here.", + (string) (len=39) "\tCustom_prefix_Here StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidStringEnum = errors.New(\"not a valid StringEnum\")", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=32) "\t\"random\": Custom_prefix_Random,", + (string) (len=32) "\t\"values\": Custom_prefix_Values,", + (string) (len=30) "\t\"here\": Custom_prefix_Here,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=39) "func (x StringEnum) Ptr() *StringEnum {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errStringEnumNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=47) "var sqlIntStringEnumMap = map[int64]StringEnum{", + (string) (len=28) "\t1114: Custom_prefix_Random,", + (string) (len=28) "\t300: Custom_prefix_Values,", + (string) (len=26) "\t1: Custom_prefix_Here,", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var sqlIntStringEnumValue = map[StringEnum]int64{", + (string) (len=28) "\tCustom_prefix_Random: 1114,", + (string) (len=27) "\tCustom_prefix_Values: 300,", + (string) (len=25) "\tCustom_prefix_Here: 1,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "func lookupSqlIntStringEnum(val int64) (StringEnum, error) {", + (string) (len=34) "\tx, ok := sqlIntStringEnumMap[val]", + (string) (len=9) "\tif !ok {", + (string) (len=65) "\t\treturn x, fmt.Errorf(\"%v is not %w\", val, ErrInvalidStringEnum)", + (string) (len=2) "\t}", + (string) (len=14) "\treturn x, nil", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=37) "\t\t*x, err = lookupSqlIntStringEnum(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=68) "\t\tif val, verr := strconv.ParseInt(string(v), 10, 64); verr == nil {", + (string) (len=40) "\t\t\t*x, err = lookupSqlIntStringEnum(val)", + (string) (len=10) "\t\t} else {", + (string) (len=39) "\t\t\t// try parsing the value as a string", + (string) (len=39) "\t\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=3) "\t\t}", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=13) "\tcase uint64:", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=36) "\tval, ok := sqlIntStringEnumValue[x]", + (string) (len=9) "\tif !ok {", + (string) (len=34) "\t\treturn nil, ErrInvalidStringEnum", + (string) (len=2) "\t}", + (string) (len=23) "\treturn int64(val), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *StringEnum) Set(val string) error {", + (string) (len=31) "\tv, err := ParseStringEnum(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *StringEnum) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *StringEnum) Type() string {", + (string) (len=20) "\treturn \"StringEnum\"", + (string) (len=1) "}", + (string) "", + (string) (len=28) "type NullStringEnum struct {", + (string) (len=22) "\tStringEnum StringEnum", + (string) (len=16) "\tValid bool", + (string) (len=16) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=60) "func NewNullStringEnum(val interface{}) (x NullStringEnum) {", + (string) (len=83) "\terr := x.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=54) "\t_ = err // make any errcheck linters happy", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=62) "func (x *NullStringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=47) "\t\tx.StringEnum, x.Valid = StringEnum(\"\"), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=31) "\terr = x.StringEnum.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=55) "func (x NullStringEnum) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=33) "\treturn string(x.StringEnum), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullStringEnum to JSON.", + (string) (len=55) "func (n NullStringEnum) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.StringEnum)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullStringEnum from JSON.", + (string) (len=56) "func (n *NullStringEnum) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=31) "type NullStringEnumStr struct {", + (string) (len=15) "\tNullStringEnum", + (string) (len=1) "}", + (string) "", + (string) (len=66) "func NewNullStringEnumStr(val interface{}) (x NullStringEnumStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x NullStringEnumStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=34) "\treturn x.StringEnum.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullStringEnum to JSON.", + (string) (len=58) "func (n NullStringEnumStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.StringEnum)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullStringEnum from JSON.", + (string) (len=59) "func (n *NullStringEnumStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", (string) "" } diff --git a/generator/.snapshots/Test118ExampleFile-1.18 b/generator/.snapshots/Test118ExampleFile-1.18 new file mode 100644 index 00000000..9cd671aa --- /dev/null +++ b/generator/.snapshots/Test118ExampleFile-1.18 @@ -0,0 +1,174 @@ +([]string) (len=172) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// ChangeTypeCreate is a ChangeType of type Create.", + (string) (len=35) "\tChangeTypeCreate ChangeType = iota", + (string) (len=52) "\t// ChangeTypeUpdate is a ChangeType of type Update.", + (string) (len=17) "\tChangeTypeUpdate", + (string) (len=52) "\t// ChangeTypeDelete is a ChangeType of type Delete.", + (string) (len=17) "\tChangeTypeDelete", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidChangeType = fmt.Errorf(\"not a valid ChangeType, try [%s]\", strings.Join(_ChangeTypeNames, \", \"))", + (string) "", + (string) (len=44) "const _ChangeTypeName = \"CreateUpdateDelete\"", + (string) "", + (string) (len=32) "var _ChangeTypeNames = []string{", + (string) (len=22) "\t_ChangeTypeName[0:6],", + (string) (len=23) "\t_ChangeTypeName[6:12],", + (string) (len=24) "\t_ChangeTypeName[12:18],", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// ChangeTypeNames returns a list of possible string values of ChangeType.", + (string) (len=33) "func ChangeTypeNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_ChangeTypeNames))", + (string) (len=28) "\tcopy(tmp, _ChangeTypeNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _ChangeTypeMap = map[ChangeType]string{", + (string) (len=40) "\tChangeTypeCreate: _ChangeTypeName[0:6],", + (string) (len=41) "\tChangeTypeUpdate: _ChangeTypeName[6:12],", + (string) (len=42) "\tChangeTypeDelete: _ChangeTypeName[12:18],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x ChangeType) String() string {", + (string) (len=38) "\tif str, ok := _ChangeTypeMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"ChangeType(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x ChangeType) IsValid() bool {", + (string) (len=27) "\t_, ok := _ChangeTypeMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _ChangeTypeValue = map[string]ChangeType{", + (string) (len=59) "\t_ChangeTypeName[0:6]: ChangeTypeCreate,", + (string) (len=59) "\tstrings.ToLower(_ChangeTypeName[0:6]): ChangeTypeCreate,", + (string) (len=59) "\t_ChangeTypeName[6:12]: ChangeTypeUpdate,", + (string) (len=59) "\tstrings.ToLower(_ChangeTypeName[6:12]): ChangeTypeUpdate,", + (string) (len=59) "\t_ChangeTypeName[12:18]: ChangeTypeDelete,", + (string) (len=59) "\tstrings.ToLower(_ChangeTypeName[12:18]): ChangeTypeDelete,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseChangeType attempts to convert a string to a ChangeType.", + (string) (len=55) "func ParseChangeType(name string) (ChangeType, error) {", + (string) (len=41) "\tif x, ok := _ChangeTypeValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _ChangeTypeValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn ChangeType(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidChangeType)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x ChangeType) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *ChangeType) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseChangeType(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errChangeTypeNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *ChangeType) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = ChangeType(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseChangeType(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseChangeType(string(v))", + (string) (len=17) "\tcase ChangeType:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=18) "\tcase *ChangeType:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseChangeType(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x ChangeType) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/generator-TestExampleFile b/generator/.snapshots/Test118ExampleFile-og similarity index 54% rename from generator/.snapshots/generator-TestExampleFile rename to generator/.snapshots/Test118ExampleFile-og index d1f21a5f..cd0d19eb 100644 --- a/generator/.snapshots/generator-TestExampleFile +++ b/generator/.snapshots/Test118ExampleFile-og @@ -1,15 +1,17 @@ -([]string) (len=1824) { - (string) (len=28) "// Code generated by go-enum", - (string) (len=15) "// DO NOT EDIT!", +([]string) (len=2420) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", (string) "", (string) (len=17) "package generator", (string) "", (string) (len=8) "import (", (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=9) "\t\"errors\"", (string) (len=6) "\t\"fmt\"", (string) (len=10) "\t\"strings\"", - (string) "", - (string) (len=24) "\t\"github.com/pkg/errors\"", (string) (len=1) ")", (string) "", (string) (len=7) "const (", @@ -21,6 +23,8 @@ (string) (len=11) "\tAnimalFish", (string) (len=1) ")", (string) "", + (string) (len=99) "var ErrInvalidAnimal = fmt.Errorf(\"not a valid Animal, try [%s]\", strings.Join(_AnimalNames, \", \"))", + (string) "", (string) (len=32) "const _AnimalName = \"CatDogFish\"", (string) "", (string) (len=28) "var _AnimalNames = []string{", @@ -37,9 +41,9 @@ (string) (len=1) "}", (string) "", (string) (len=35) "var _AnimalMap = map[Animal]string{", - (string) (len=21) "\t0: _AnimalName[0:3],", - (string) (len=21) "\t1: _AnimalName[3:6],", - (string) (len=22) "\t2: _AnimalName[6:10],", + (string) (len=30) "\tAnimalCat: _AnimalName[0:3],", + (string) (len=30) "\tAnimalDog: _AnimalName[3:6],", + (string) (len=31) "\tAnimalFish: _AnimalName[6:10],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -50,16 +54,23 @@ (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=37) "var _AnimalValue = map[string]Animal{", - (string) (len=39) "\t_AnimalName[0:3]: 0,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[0:3]): 0,", - (string) (len=39) "\t_AnimalName[3:6]: 1,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[3:6]): 1,", - (string) (len=39) "\t_AnimalName[6:10]: 2,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[6:10]): 2,", + (string) (len=47) "\t_AnimalName[0:3]: AnimalCat,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[0:3]): AnimalCat,", + (string) (len=47) "\t_AnimalName[3:6]: AnimalDog,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[3:6]): AnimalDog,", + (string) (len=48) "\t_AnimalName[6:10]: AnimalFish,", + (string) (len=48) "\tstrings.ToLower(_AnimalName[6:10]): AnimalFish,", (string) (len=1) "}", (string) "", - (string) (len=55) "// ParseAnimal attempts to convert a string to a Animal", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -68,15 +79,15 @@ (string) (len=54) "\tif x, ok := _AnimalValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=107) "\treturn Animal(0), fmt.Errorf(\"%s is not a valid Animal, try [%s]\", name, strings.Join(_AnimalNames, \", \"))", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=30) "\ttmp, err := ParseAnimal(name)", @@ -87,7 +98,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=93) "var _AnimalErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=92) "var errAnimalNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=54) "func (x *Animal) Scan(value interface{}) (err error) {", @@ -111,7 +122,7 @@ (string) (len=16) "\t\t*x = Animal(v)", (string) (len=14) "\tcase *Animal:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -120,34 +131,34 @@ (string) (len=16) "\t\t*x = Animal(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=16) "\t\t*x = Animal(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=17) "\t\t*x = Animal(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=26) "\t\t\treturn _AnimalErrNilPtr", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x, err = ParseAnimal(*v)", (string) (len=2) "\t}", @@ -169,6 +180,8 @@ (string) (len=27) "\tCasesAnotherLowerCaseStart", (string) (len=1) ")", (string) "", + (string) (len=96) "var ErrInvalidCases = fmt.Errorf(\"not a valid Cases, try [%s]\", strings.Join(_CasesNames, \", \"))", + (string) "", (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", (string) "", (string) (len=27) "var _CasesNames = []string{", @@ -185,9 +198,9 @@ (string) (len=1) "}", (string) "", (string) (len=33) "var _CasesMap = map[Cases]string{", - (string) (len=21) "\t0: _CasesName[0:10],", - (string) (len=22) "\t1: _CasesName[10:22],", - (string) (len=22) "\t2: _CasesName[22:43],", + (string) (len=46) "\tCasesTest_lower: _CasesName[0:10],", + (string) (len=47) "\tCasesTest_capital: _CasesName[10:22],", + (string) (len=47) "\tCasesAnotherLowerCaseStart: _CasesName[22:43],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -198,16 +211,23 @@ (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=35) "var _CasesValue = map[string]Cases{", - (string) (len=39) "\t_CasesName[0:10]: 0,", - (string) (len=39) "\tstrings.ToLower(_CasesName[0:10]): 0,", - (string) (len=39) "\t_CasesName[10:22]: 1,", - (string) (len=39) "\tstrings.ToLower(_CasesName[10:22]): 1,", - (string) (len=39) "\t_CasesName[22:43]: 2,", - (string) (len=39) "\tstrings.ToLower(_CasesName[22:43]): 2,", + (string) (len=53) "\t_CasesName[0:10]: CasesTest_lower,", + (string) (len=53) "\tstrings.ToLower(_CasesName[0:10]): CasesTest_lower,", + (string) (len=55) "\t_CasesName[10:22]: CasesTest_capital,", + (string) (len=55) "\tstrings.ToLower(_CasesName[10:22]): CasesTest_capital,", + (string) (len=64) "\t_CasesName[22:43]: CasesAnotherLowerCaseStart,", + (string) (len=64) "\tstrings.ToLower(_CasesName[22:43]): CasesAnotherLowerCaseStart,", (string) (len=1) "}", (string) "", - (string) (len=53) "// ParseCases attempts to convert a string to a Cases", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", (string) (len=45) "func ParseCases(name string) (Cases, error) {", (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -216,15 +236,15 @@ (string) (len=53) "\tif x, ok := _CasesValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=104) "\treturn Cases(0), fmt.Errorf(\"%s is not a valid Cases, try [%s]\", name, strings.Join(_CasesNames, \", \"))", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=29) "\ttmp, err := ParseCases(name)", @@ -235,7 +255,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=92) "var _CasesErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=91) "var errCasesNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=53) "func (x *Cases) Scan(value interface{}) (err error) {", @@ -259,7 +279,7 @@ (string) (len=15) "\t\t*x = Cases(v)", (string) (len=13) "\tcase *Cases:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -268,34 +288,34 @@ (string) (len=15) "\t\t*x = Cases(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\t*x = Cases(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Cases(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _CasesErrNilPtr", + (string) (len=24) "\t\t\treturn errCasesNilPtr", (string) (len=3) "\t\t}", (string) (len=26) "\t\t*x, err = ParseCases(*v)", (string) (len=2) "\t}", @@ -325,6 +345,8 @@ (string) (len=12) "\tColorYellow", (string) (len=1) ")", (string) "", + (string) (len=96) "var ErrInvalidColor = fmt.Errorf(\"not a valid Color, try [%s]\", strings.Join(_ColorNames, \", \"))", + (string) "", (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", (string) "", (string) (len=27) "var _ColorNames = []string{", @@ -345,13 +367,13 @@ (string) (len=1) "}", (string) "", (string) (len=33) "var _ColorMap = map[Color]string{", - (string) (len=21) "\t0: _ColorName[0:5],", - (string) (len=22) "\t1: _ColorName[5:10],", - (string) (len=23) "\t2: _ColorName[10:13],", - (string) (len=23) "\t3: _ColorName[13:18],", - (string) (len=23) "\t33: _ColorName[18:22],", - (string) (len=23) "\t34: _ColorName[22:26],", - (string) (len=23) "\t35: _ColorName[26:32],", + (string) (len=30) "\tColorBlack: _ColorName[0:5],", + (string) (len=31) "\tColorWhite: _ColorName[5:10],", + (string) (len=32) "\tColorRed: _ColorName[10:13],", + (string) (len=32) "\tColorGreen: _ColorName[13:18],", + (string) (len=32) "\tColorBlue: _ColorName[18:22],", + (string) (len=32) "\tColorGrey: _ColorName[22:26],", + (string) (len=32) "\tColorYellow: _ColorName[26:32],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -362,24 +384,31 @@ (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=35) "var _ColorValue = map[string]Color{", - (string) (len=39) "\t_ColorName[0:5]: 0,", - (string) (len=39) "\tstrings.ToLower(_ColorName[0:5]): 0,", - (string) (len=39) "\t_ColorName[5:10]: 1,", - (string) (len=39) "\tstrings.ToLower(_ColorName[5:10]): 1,", - (string) (len=39) "\t_ColorName[10:13]: 2,", - (string) (len=39) "\tstrings.ToLower(_ColorName[10:13]): 2,", - (string) (len=39) "\t_ColorName[13:18]: 3,", - (string) (len=39) "\tstrings.ToLower(_ColorName[13:18]): 3,", - (string) (len=40) "\t_ColorName[18:22]: 33,", - (string) (len=40) "\tstrings.ToLower(_ColorName[18:22]): 33,", - (string) (len=40) "\t_ColorName[22:26]: 34,", - (string) (len=40) "\tstrings.ToLower(_ColorName[22:26]): 34,", - (string) (len=40) "\t_ColorName[26:32]: 35,", - (string) (len=40) "\tstrings.ToLower(_ColorName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseColor attempts to convert a string to a Color", + (string) (len=48) "\t_ColorName[0:5]: ColorBlack,", + (string) (len=48) "\tstrings.ToLower(_ColorName[0:5]): ColorBlack,", + (string) (len=48) "\t_ColorName[5:10]: ColorWhite,", + (string) (len=48) "\tstrings.ToLower(_ColorName[5:10]): ColorWhite,", + (string) (len=46) "\t_ColorName[10:13]: ColorRed,", + (string) (len=46) "\tstrings.ToLower(_ColorName[10:13]): ColorRed,", + (string) (len=48) "\t_ColorName[13:18]: ColorGreen,", + (string) (len=48) "\tstrings.ToLower(_ColorName[13:18]): ColorGreen,", + (string) (len=47) "\t_ColorName[18:22]: ColorBlue,", + (string) (len=47) "\tstrings.ToLower(_ColorName[18:22]): ColorBlue,", + (string) (len=47) "\t_ColorName[22:26]: ColorGrey,", + (string) (len=47) "\tstrings.ToLower(_ColorName[22:26]): ColorGrey,", + (string) (len=49) "\t_ColorName[26:32]: ColorYellow,", + (string) (len=49) "\tstrings.ToLower(_ColorName[26:32]): ColorYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", (string) (len=45) "func ParseColor(name string) (Color, error) {", (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -388,15 +417,15 @@ (string) (len=53) "\tif x, ok := _ColorValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=104) "\treturn Color(0), fmt.Errorf(\"%s is not a valid Color, try [%s]\", name, strings.Join(_ColorNames, \", \"))", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=29) "\ttmp, err := ParseColor(name)", @@ -407,7 +436,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=92) "var _ColorErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=91) "var errColorNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=53) "func (x *Color) Scan(value interface{}) (err error) {", @@ -431,7 +460,7 @@ (string) (len=15) "\t\t*x = Color(v)", (string) (len=13) "\tcase *Color:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -440,34 +469,34 @@ (string) (len=15) "\t\t*x = Color(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\t*x = Color(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Color(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ColorErrNilPtr", + (string) (len=24) "\t\t\treturn errColorNilPtr", (string) (len=3) "\t\t}", (string) (len=26) "\t\t*x, err = ParseColor(*v)", (string) (len=2) "\t}", @@ -490,7 +519,7 @@ (string) (len=62) "\t// ColorWithCommentGreen is a ColorWithComment of type Green.", (string) (len=22) "\tColorWithCommentGreen", (string) (len=60) "\t// ColorWithCommentBlue is a ColorWithComment of type Blue.", - (string) (len=23) "\t// Blue starts with 33", + (string) (len=24) "\t// Blue starts with 33.", (string) (len=50) "\tColorWithCommentBlue ColorWithComment = iota + 29", (string) (len=60) "\t// ColorWithCommentGrey is a ColorWithComment of type Grey.", (string) (len=21) "\tColorWithCommentGrey", @@ -498,6 +527,8 @@ (string) (len=23) "\tColorWithCommentYellow", (string) (len=1) ")", (string) "", + (string) (len=129) "var ErrInvalidColorWithComment = fmt.Errorf(\"not a valid ColorWithComment, try [%s]\", strings.Join(_ColorWithCommentNames, \", \"))", + (string) "", (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", (string) "", (string) (len=38) "var _ColorWithCommentNames = []string{", @@ -518,13 +549,13 @@ (string) (len=1) "}", (string) "", (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", - (string) (len=32) "\t0: _ColorWithCommentName[0:5],", - (string) (len=33) "\t1: _ColorWithCommentName[5:10],", - (string) (len=34) "\t2: _ColorWithCommentName[10:13],", - (string) (len=34) "\t3: _ColorWithCommentName[13:18],", - (string) (len=34) "\t33: _ColorWithCommentName[18:22],", - (string) (len=34) "\t34: _ColorWithCommentName[22:26],", - (string) (len=34) "\t35: _ColorWithCommentName[26:32],", + (string) (len=52) "\tColorWithCommentBlack: _ColorWithCommentName[0:5],", + (string) (len=53) "\tColorWithCommentWhite: _ColorWithCommentName[5:10],", + (string) (len=54) "\tColorWithCommentRed: _ColorWithCommentName[10:13],", + (string) (len=54) "\tColorWithCommentGreen: _ColorWithCommentName[13:18],", + (string) (len=54) "\tColorWithCommentBlue: _ColorWithCommentName[18:22],", + (string) (len=54) "\tColorWithCommentGrey: _ColorWithCommentName[22:26],", + (string) (len=54) "\tColorWithCommentYellow: _ColorWithCommentName[26:32],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -535,24 +566,31 @@ (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", - (string) (len=50) "\t_ColorWithCommentName[0:5]: 0,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[0:5]): 0,", - (string) (len=50) "\t_ColorWithCommentName[5:10]: 1,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[5:10]): 1,", - (string) (len=50) "\t_ColorWithCommentName[10:13]: 2,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[10:13]): 2,", - (string) (len=50) "\t_ColorWithCommentName[13:18]: 3,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[13:18]): 3,", - (string) (len=51) "\t_ColorWithCommentName[18:22]: 33,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[18:22]): 33,", - (string) (len=51) "\t_ColorWithCommentName[22:26]: 34,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[22:26]): 34,", - (string) (len=51) "\t_ColorWithCommentName[26:32]: 35,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=75) "// ParseColorWithComment attempts to convert a string to a ColorWithComment", + (string) (len=70) "\t_ColorWithCommentName[0:5]: ColorWithCommentBlack,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[0:5]): ColorWithCommentBlack,", + (string) (len=70) "\t_ColorWithCommentName[5:10]: ColorWithCommentWhite,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[5:10]): ColorWithCommentWhite,", + (string) (len=68) "\t_ColorWithCommentName[10:13]: ColorWithCommentRed,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[10:13]): ColorWithCommentRed,", + (string) (len=70) "\t_ColorWithCommentName[13:18]: ColorWithCommentGreen,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[13:18]): ColorWithCommentGreen,", + (string) (len=69) "\t_ColorWithCommentName[18:22]: ColorWithCommentBlue,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[18:22]): ColorWithCommentBlue,", + (string) (len=69) "\t_ColorWithCommentName[22:26]: ColorWithCommentGrey,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[22:26]): ColorWithCommentGrey,", + (string) (len=71) "\t_ColorWithCommentName[26:32]: ColorWithCommentYellow,", + (string) (len=71) "\tstrings.ToLower(_ColorWithCommentName[26:32]): ColorWithCommentYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -561,15 +599,15 @@ (string) (len=64) "\tif x, ok := _ColorWithCommentValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=137) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is not a valid ColorWithComment, try [%s]\", name, strings.Join(_ColorWithCommentNames, \", \"))", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", @@ -580,7 +618,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=103) "var _ColorWithCommentErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=102) "var errColorWithCommentNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=64) "func (x *ColorWithComment) Scan(value interface{}) (err error) {", @@ -604,7 +642,7 @@ (string) (len=26) "\t\t*x = ColorWithComment(v)", (string) (len=24) "\tcase *ColorWithComment:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -613,34 +651,34 @@ (string) (len=26) "\t\t*x = ColorWithComment(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=26) "\t\t*x = ColorWithComment(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=27) "\t\t*x = ColorWithComment(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=36) "\t\t\treturn _ColorWithCommentErrNilPtr", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", (string) (len=3) "\t\t}", (string) (len=37) "\t\t*x, err = ParseColorWithComment(*v)", (string) (len=2) "\t}", @@ -671,6 +709,8 @@ (string) (len=24) "\tColorWithComment2Yellow", (string) (len=1) ")", (string) "", + (string) (len=132) "var ErrInvalidColorWithComment2 = fmt.Errorf(\"not a valid ColorWithComment2, try [%s]\", strings.Join(_ColorWithComment2Names, \", \"))", + (string) "", (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", (string) "", (string) (len=39) "var _ColorWithComment2Names = []string{", @@ -691,13 +731,13 @@ (string) (len=1) "}", (string) "", (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", - (string) (len=33) "\t0: _ColorWithComment2Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment2Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment2Name[10:13],", - (string) (len=35) "\t3: _ColorWithComment2Name[13:18],", - (string) (len=35) "\t33: _ColorWithComment2Name[18:22],", - (string) (len=35) "\t34: _ColorWithComment2Name[22:26],", - (string) (len=35) "\t35: _ColorWithComment2Name[26:32],", + (string) (len=54) "\tColorWithComment2Black: _ColorWithComment2Name[0:5],", + (string) (len=55) "\tColorWithComment2White: _ColorWithComment2Name[5:10],", + (string) (len=56) "\tColorWithComment2Red: _ColorWithComment2Name[10:13],", + (string) (len=56) "\tColorWithComment2Green: _ColorWithComment2Name[13:18],", + (string) (len=56) "\tColorWithComment2Blue: _ColorWithComment2Name[18:22],", + (string) (len=56) "\tColorWithComment2Grey: _ColorWithComment2Name[22:26],", + (string) (len=56) "\tColorWithComment2Yellow: _ColorWithComment2Name[26:32],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -708,24 +748,31 @@ (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", - (string) (len=51) "\t_ColorWithComment2Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment2Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment2Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): 2,", - (string) (len=51) "\t_ColorWithComment2Name[13:18]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): 3,", - (string) (len=52) "\t_ColorWithComment2Name[18:22]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): 33,", - (string) (len=52) "\t_ColorWithComment2Name[22:26]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): 34,", - (string) (len=52) "\t_ColorWithComment2Name[26:32]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2", + (string) (len=72) "\t_ColorWithComment2Name[0:5]: ColorWithComment2Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): ColorWithComment2Black,", + (string) (len=72) "\t_ColorWithComment2Name[5:10]: ColorWithComment2White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): ColorWithComment2White,", + (string) (len=70) "\t_ColorWithComment2Name[10:13]: ColorWithComment2Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): ColorWithComment2Red,", + (string) (len=72) "\t_ColorWithComment2Name[13:18]: ColorWithComment2Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): ColorWithComment2Green,", + (string) (len=71) "\t_ColorWithComment2Name[18:22]: ColorWithComment2Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): ColorWithComment2Blue,", + (string) (len=71) "\t_ColorWithComment2Name[22:26]: ColorWithComment2Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): ColorWithComment2Grey,", + (string) (len=73) "\t_ColorWithComment2Name[26:32]: ColorWithComment2Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): ColorWithComment2Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -734,15 +781,15 @@ (string) (len=65) "\tif x, ok := _ColorWithComment2Value[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=140) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is not a valid ColorWithComment2, try [%s]\", name, strings.Join(_ColorWithComment2Names, \", \"))", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", @@ -753,7 +800,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=104) "var _ColorWithComment2ErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=103) "var errColorWithComment2NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=65) "func (x *ColorWithComment2) Scan(value interface{}) (err error) {", @@ -777,7 +824,7 @@ (string) (len=27) "\t\t*x = ColorWithComment2(v)", (string) (len=25) "\tcase *ColorWithComment2:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -786,34 +833,34 @@ (string) (len=27) "\t\t*x = ColorWithComment2(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=27) "\t\t*x = ColorWithComment2(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment2(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment2ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", (string) (len=3) "\t\t}", (string) (len=38) "\t\t*x, err = ParseColorWithComment2(*v)", (string) (len=2) "\t}", @@ -851,6 +898,8 @@ (string) (len=31) "\tColorWithComment3RedOrangeBlue", (string) (len=1) ")", (string) "", + (string) (len=132) "var ErrInvalidColorWithComment3 = fmt.Errorf(\"not a valid ColorWithComment3, try [%s]\", strings.Join(_ColorWithComment3Names, \", \"))", + (string) "", (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", (string) "", (string) (len=39) "var _ColorWithComment3Names = []string{", @@ -874,16 +923,16 @@ (string) (len=1) "}", (string) "", (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", - (string) (len=33) "\t0: _ColorWithComment3Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment3Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment3Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment3Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment3Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment3Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment3Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment3Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment3Name[42:52],", - (string) (len=35) "\t39: _ColorWithComment3Name[52:67],", + (string) (len=61) "\tColorWithComment3Black: _ColorWithComment3Name[0:5],", + (string) (len=62) "\tColorWithComment3White: _ColorWithComment3Name[5:10],", + (string) (len=63) "\tColorWithComment3Red: _ColorWithComment3Name[10:13],", + (string) (len=63) "\tColorWithComment3Green: _ColorWithComment3Name[13:18],", + (string) (len=63) "\tColorWithComment3Blue: _ColorWithComment3Name[18:22],", + (string) (len=63) "\tColorWithComment3Grey: _ColorWithComment3Name[22:26],", + (string) (len=63) "\tColorWithComment3Yellow: _ColorWithComment3Name[26:32],", + (string) (len=63) "\tColorWithComment3BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=63) "\tColorWithComment3RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=63) "\tColorWithComment3RedOrangeBlue: _ColorWithComment3Name[52:67],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -894,30 +943,37 @@ (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", - (string) (len=51) "\t_ColorWithComment3Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment3Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment3Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): 2,", - (string) (len=52) "\t_ColorWithComment3Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment3Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment3Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment3Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment3Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment3Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): 38,", - (string) (len=52) "\t_ColorWithComment3Name[52:67]: 39,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): 39,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3", + (string) (len=72) "\t_ColorWithComment3Name[0:5]: ColorWithComment3Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): ColorWithComment3Black,", + (string) (len=72) "\t_ColorWithComment3Name[5:10]: ColorWithComment3White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): ColorWithComment3White,", + (string) (len=70) "\t_ColorWithComment3Name[10:13]: ColorWithComment3Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): ColorWithComment3Red,", + (string) (len=72) "\t_ColorWithComment3Name[13:18]: ColorWithComment3Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): ColorWithComment3Green,", + (string) (len=71) "\t_ColorWithComment3Name[18:22]: ColorWithComment3Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): ColorWithComment3Blue,", + (string) (len=71) "\t_ColorWithComment3Name[22:26]: ColorWithComment3Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): ColorWithComment3Grey,", + (string) (len=73) "\t_ColorWithComment3Name[26:32]: ColorWithComment3Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): ColorWithComment3Yellow,", + (string) (len=76) "\t_ColorWithComment3Name[32:42]: ColorWithComment3BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): ColorWithComment3BlueGreen,", + (string) (len=76) "\t_ColorWithComment3Name[42:52]: ColorWithComment3RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): ColorWithComment3RedOrange,", + (string) (len=80) "\t_ColorWithComment3Name[52:67]: ColorWithComment3RedOrangeBlue,", + (string) (len=80) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): ColorWithComment3RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -926,15 +982,15 @@ (string) (len=65) "\tif x, ok := _ColorWithComment3Value[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=140) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is not a valid ColorWithComment3, try [%s]\", name, strings.Join(_ColorWithComment3Names, \", \"))", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", @@ -945,7 +1001,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=104) "var _ColorWithComment3ErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=103) "var errColorWithComment3NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=65) "func (x *ColorWithComment3) Scan(value interface{}) (err error) {", @@ -969,7 +1025,7 @@ (string) (len=27) "\t\t*x = ColorWithComment3(v)", (string) (len=25) "\tcase *ColorWithComment3:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -978,34 +1034,34 @@ (string) (len=27) "\t\t*x = ColorWithComment3(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=27) "\t\t*x = ColorWithComment3(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment3(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment3ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", (string) (len=3) "\t\t}", (string) (len=38) "\t\t*x, err = ParseColorWithComment3(*v)", (string) (len=2) "\t}", @@ -1046,6 +1102,8 @@ (string) (len=27) "\tColorWithComment4RedOrange", (string) (len=1) ")", (string) "", + (string) (len=132) "var ErrInvalidColorWithComment4 = fmt.Errorf(\"not a valid ColorWithComment4, try [%s]\", strings.Join(_ColorWithComment4Names, \", \"))", + (string) "", (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", (string) "", (string) (len=39) "var _ColorWithComment4Names = []string{", @@ -1068,15 +1126,15 @@ (string) (len=1) "}", (string) "", (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", - (string) (len=33) "\t1: _ColorWithComment4Name[0:5],", - (string) (len=34) "\t2: _ColorWithComment4Name[5:10],", - (string) (len=35) "\t3: _ColorWithComment4Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment4Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment4Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment4Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment4Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment4Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment4Name[42:52],", + (string) (len=57) "\tColorWithComment4Black: _ColorWithComment4Name[0:5],", + (string) (len=58) "\tColorWithComment4White: _ColorWithComment4Name[5:10],", + (string) (len=59) "\tColorWithComment4Red: _ColorWithComment4Name[10:13],", + (string) (len=59) "\tColorWithComment4Green: _ColorWithComment4Name[13:18],", + (string) (len=59) "\tColorWithComment4Blue: _ColorWithComment4Name[18:22],", + (string) (len=59) "\tColorWithComment4Grey: _ColorWithComment4Name[22:26],", + (string) (len=59) "\tColorWithComment4Yellow: _ColorWithComment4Name[26:32],", + (string) (len=59) "\tColorWithComment4BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=59) "\tColorWithComment4RedOrange: _ColorWithComment4Name[42:52],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1087,28 +1145,35 @@ (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", - (string) (len=51) "\t_ColorWithComment4Name[0:5]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): 1,", - (string) (len=51) "\t_ColorWithComment4Name[5:10]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): 2,", - (string) (len=51) "\t_ColorWithComment4Name[10:13]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): 3,", - (string) (len=52) "\t_ColorWithComment4Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment4Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment4Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment4Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment4Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment4Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): 38,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4", + (string) (len=72) "\t_ColorWithComment4Name[0:5]: ColorWithComment4Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): ColorWithComment4Black,", + (string) (len=72) "\t_ColorWithComment4Name[5:10]: ColorWithComment4White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): ColorWithComment4White,", + (string) (len=70) "\t_ColorWithComment4Name[10:13]: ColorWithComment4Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): ColorWithComment4Red,", + (string) (len=72) "\t_ColorWithComment4Name[13:18]: ColorWithComment4Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): ColorWithComment4Green,", + (string) (len=71) "\t_ColorWithComment4Name[18:22]: ColorWithComment4Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): ColorWithComment4Blue,", + (string) (len=71) "\t_ColorWithComment4Name[22:26]: ColorWithComment4Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): ColorWithComment4Grey,", + (string) (len=73) "\t_ColorWithComment4Name[26:32]: ColorWithComment4Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): ColorWithComment4Yellow,", + (string) (len=76) "\t_ColorWithComment4Name[32:42]: ColorWithComment4BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): ColorWithComment4BlueGreen,", + (string) (len=76) "\t_ColorWithComment4Name[42:52]: ColorWithComment4RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): ColorWithComment4RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -1117,15 +1182,15 @@ (string) (len=65) "\tif x, ok := _ColorWithComment4Value[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=140) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is not a valid ColorWithComment4, try [%s]\", name, strings.Join(_ColorWithComment4Names, \", \"))", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", @@ -1136,7 +1201,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=104) "var _ColorWithComment4ErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=103) "var errColorWithComment4NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=65) "func (x *ColorWithComment4) Scan(value interface{}) (err error) {", @@ -1160,7 +1225,7 @@ (string) (len=27) "\t\t*x = ColorWithComment4(v)", (string) (len=25) "\tcase *ColorWithComment4:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1169,34 +1234,34 @@ (string) (len=27) "\t\t*x = ColorWithComment4(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=27) "\t\t*x = ColorWithComment4(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=28) "\t\t*x = ColorWithComment4(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=37) "\t\t\treturn _ColorWithComment4ErrNilPtr", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", (string) (len=3) "\t\t}", (string) (len=38) "\t\t*x, err = ParseColorWithComment4(*v)", (string) (len=2) "\t}", @@ -1210,6 +1275,235 @@ (string) (len=1) "}", (string) "", (string) (len=7) "const (", + (string) (len=52) "\t// Enum64bitUnknown is a Enum64bit of type Unknown.", + (string) (len=34) "\tEnum64bitUnknown Enum64bit = iota", + (string) (len=48) "\t// Enum64bitE2P15 is a Enum64bit of type E2P15.", + (string) (len=40) "\tEnum64bitE2P15 Enum64bit = iota + 32767", + (string) (len=48) "\t// Enum64bitE2P16 is a Enum64bit of type E2P16.", + (string) (len=40) "\tEnum64bitE2P16 Enum64bit = iota + 65534", + (string) (len=48) "\t// Enum64bitE2P17 is a Enum64bit of type E2P17.", + (string) (len=41) "\tEnum64bitE2P17 Enum64bit = iota + 131069", + (string) (len=48) "\t// Enum64bitE2P18 is a Enum64bit of type E2P18.", + (string) (len=41) "\tEnum64bitE2P18 Enum64bit = iota + 262140", + (string) (len=48) "\t// Enum64bitE2P19 is a Enum64bit of type E2P19.", + (string) (len=41) "\tEnum64bitE2P19 Enum64bit = iota + 524283", + (string) (len=48) "\t// Enum64bitE2P20 is a Enum64bit of type E2P20.", + (string) (len=42) "\tEnum64bitE2P20 Enum64bit = iota + 1048570", + (string) (len=48) "\t// Enum64bitE2P21 is a Enum64bit of type E2P21.", + (string) (len=42) "\tEnum64bitE2P21 Enum64bit = iota + 2097145", + (string) (len=48) "\t// Enum64bitE2P22 is a Enum64bit of type E2P22.", + (string) (len=43) "\tEnum64bitE2P22 Enum64bit = iota + 33554424", + (string) (len=48) "\t// Enum64bitE2P23 is a Enum64bit of type E2P23.", + (string) (len=43) "\tEnum64bitE2P23 Enum64bit = iota + 67108855", + (string) (len=48) "\t// Enum64bitE2P28 is a Enum64bit of type E2P28.", + (string) (len=44) "\tEnum64bitE2P28 Enum64bit = iota + 536870902", + (string) (len=48) "\t// Enum64bitE2P30 is a Enum64bit of type E2P30.", + (string) (len=45) "\tEnum64bitE2P30 Enum64bit = iota + 1073741813", + (string) (len=48) "\t// Enum64bitE2P31 is a Enum64bit of type E2P31.", + (string) (len=45) "\tEnum64bitE2P31 Enum64bit = iota + 2147483636", + (string) (len=48) "\t// Enum64bitE2P32 is a Enum64bit of type E2P32.", + (string) (len=45) "\tEnum64bitE2P32 Enum64bit = iota + 4294967283", + (string) (len=48) "\t// Enum64bitE2P33 is a Enum64bit of type E2P33.", + (string) (len=45) "\tEnum64bitE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=108) "var ErrInvalidEnum64bit = fmt.Errorf(\"not a valid Enum64bit, try [%s]\", strings.Join(_Enum64bitNames, \", \"))", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=31) "var _Enum64bitNames = []string{", + (string) (len=21) "\t_Enum64bitName[0:7],", + (string) (len=22) "\t_Enum64bitName[7:12],", + (string) (len=23) "\t_Enum64bitName[12:17],", + (string) (len=23) "\t_Enum64bitName[17:22],", + (string) (len=23) "\t_Enum64bitName[22:27],", + (string) (len=23) "\t_Enum64bitName[27:32],", + (string) (len=23) "\t_Enum64bitName[32:37],", + (string) (len=23) "\t_Enum64bitName[37:42],", + (string) (len=23) "\t_Enum64bitName[42:47],", + (string) (len=23) "\t_Enum64bitName[47:52],", + (string) (len=23) "\t_Enum64bitName[52:57],", + (string) (len=23) "\t_Enum64bitName[57:62],", + (string) (len=23) "\t_Enum64bitName[62:67],", + (string) (len=23) "\t_Enum64bitName[67:72],", + (string) (len=23) "\t_Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=72) "// Enum64bitNames returns a list of possible string values of Enum64bit.", + (string) (len=32) "func Enum64bitNames() []string {", + (string) (len=44) "\ttmp := make([]string, len(_Enum64bitNames))", + (string) (len=27) "\tcopy(tmp, _Enum64bitNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=39) "\tEnum64bitUnknown: _Enum64bitName[0:7],", + (string) (len=40) "\tEnum64bitE2P15: _Enum64bitName[7:12],", + (string) (len=41) "\tEnum64bitE2P16: _Enum64bitName[12:17],", + (string) (len=41) "\tEnum64bitE2P17: _Enum64bitName[17:22],", + (string) (len=41) "\tEnum64bitE2P18: _Enum64bitName[22:27],", + (string) (len=41) "\tEnum64bitE2P19: _Enum64bitName[27:32],", + (string) (len=41) "\tEnum64bitE2P20: _Enum64bitName[32:37],", + (string) (len=41) "\tEnum64bitE2P21: _Enum64bitName[37:42],", + (string) (len=41) "\tEnum64bitE2P22: _Enum64bitName[42:47],", + (string) (len=41) "\tEnum64bitE2P23: _Enum64bitName[47:52],", + (string) (len=41) "\tEnum64bitE2P28: _Enum64bitName[52:57],", + (string) (len=41) "\tEnum64bitE2P30: _Enum64bitName[57:62],", + (string) (len=41) "\tEnum64bitE2P31: _Enum64bitName[62:67],", + (string) (len=41) "\tEnum64bitE2P32: _Enum64bitName[67:72],", + (string) (len=41) "\tEnum64bitE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=58) "\t_Enum64bitName[0:7]: Enum64bitUnknown,", + (string) (len=58) "\tstrings.ToLower(_Enum64bitName[0:7]): Enum64bitUnknown,", + (string) (len=56) "\t_Enum64bitName[7:12]: Enum64bitE2P15,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[7:12]): Enum64bitE2P15,", + (string) (len=56) "\t_Enum64bitName[12:17]: Enum64bitE2P16,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[12:17]): Enum64bitE2P16,", + (string) (len=56) "\t_Enum64bitName[17:22]: Enum64bitE2P17,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[17:22]): Enum64bitE2P17,", + (string) (len=56) "\t_Enum64bitName[22:27]: Enum64bitE2P18,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[22:27]): Enum64bitE2P18,", + (string) (len=56) "\t_Enum64bitName[27:32]: Enum64bitE2P19,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[27:32]): Enum64bitE2P19,", + (string) (len=56) "\t_Enum64bitName[32:37]: Enum64bitE2P20,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[32:37]): Enum64bitE2P20,", + (string) (len=56) "\t_Enum64bitName[37:42]: Enum64bitE2P21,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[37:42]): Enum64bitE2P21,", + (string) (len=56) "\t_Enum64bitName[42:47]: Enum64bitE2P22,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[42:47]): Enum64bitE2P22,", + (string) (len=56) "\t_Enum64bitName[47:52]: Enum64bitE2P23,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[47:52]): Enum64bitE2P23,", + (string) (len=56) "\t_Enum64bitName[52:57]: Enum64bitE2P28,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[52:57]): Enum64bitE2P28,", + (string) (len=56) "\t_Enum64bitName[57:62]: Enum64bitE2P30,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[57:62]): Enum64bitE2P30,", + (string) (len=56) "\t_Enum64bitName[62:67]: Enum64bitE2P31,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[62:67]): Enum64bitE2P31,", + (string) (len=56) "\t_Enum64bitName[67:72]: Enum64bitE2P32,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[67:72]): Enum64bitE2P32,", + (string) (len=56) "\t_Enum64bitName[72:77]: Enum64bitE2P33,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[72:77]): Enum64bitE2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=57) "\tif x, ok := _Enum64bitValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=95) "var errEnum64bitNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *Enum64bit) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=19) "\t\t*x = Enum64bit(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase string:", + (string) (len=29) "\t\t*x, err = ParseEnum64bit(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=37) "\t\t*x, err = ParseEnum64bit(string(v))", + (string) (len=16) "\tcase Enum64bit:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=17) "\tcase *Enum64bit:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=30) "\t\t*x, err = ParseEnum64bit(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x Enum64bit) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", (string) (len=42) "\t// ModelToyota is a Model of type Toyota.", (string) (len=25) "\tModelToyota Model = iota", (string) (len=18) "\t// Skipped value.", @@ -1222,6 +1516,8 @@ (string) (len=10) "\tModelFord", (string) (len=1) ")", (string) "", + (string) (len=96) "var ErrInvalidModel = fmt.Errorf(\"not a valid Model, try [%s]\", strings.Join(_ModelNames, \", \"))", + (string) "", (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", (string) "", (string) (len=27) "var _ModelNames = []string{", @@ -1238,9 +1534,9 @@ (string) (len=1) "}", (string) "", (string) (len=33) "var _ModelMap = map[Model]string{", - (string) (len=20) "\t0: _ModelName[0:6],", - (string) (len=21) "\t2: _ModelName[6:11],", - (string) (len=22) "\t4: _ModelName[11:15],", + (string) (len=30) "\tModelToyota: _ModelName[0:6],", + (string) (len=31) "\tModelChevy: _ModelName[6:11],", + (string) (len=32) "\tModelFord: _ModelName[11:15],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1251,16 +1547,23 @@ (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=35) "var _ModelValue = map[string]Model{", - (string) (len=39) "\t_ModelName[0:6]: 0,", - (string) (len=39) "\tstrings.ToLower(_ModelName[0:6]): 0,", - (string) (len=39) "\t_ModelName[6:11]: 2,", - (string) (len=39) "\tstrings.ToLower(_ModelName[6:11]): 2,", - (string) (len=39) "\t_ModelName[11:15]: 4,", - (string) (len=39) "\tstrings.ToLower(_ModelName[11:15]): 4,", + (string) (len=49) "\t_ModelName[0:6]: ModelToyota,", + (string) (len=49) "\tstrings.ToLower(_ModelName[0:6]): ModelToyota,", + (string) (len=48) "\t_ModelName[6:11]: ModelChevy,", + (string) (len=48) "\tstrings.ToLower(_ModelName[6:11]): ModelChevy,", + (string) (len=47) "\t_ModelName[11:15]: ModelFord,", + (string) (len=47) "\tstrings.ToLower(_ModelName[11:15]): ModelFord,", (string) (len=1) "}", (string) "", - (string) (len=53) "// ParseModel attempts to convert a string to a Model", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", (string) (len=45) "func ParseModel(name string) (Model, error) {", (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -1269,15 +1572,15 @@ (string) (len=53) "\tif x, ok := _ModelValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=104) "\treturn Model(0), fmt.Errorf(\"%s is not a valid Model, try [%s]\", name, strings.Join(_ModelNames, \", \"))", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=29) "\ttmp, err := ParseModel(name)", @@ -1288,7 +1591,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=92) "var _ModelErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=91) "var errModelNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=53) "func (x *Model) Scan(value interface{}) (err error) {", @@ -1312,7 +1615,7 @@ (string) (len=15) "\t\t*x = Model(v)", (string) (len=13) "\tcase *Model:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1321,34 +1624,34 @@ (string) (len=15) "\t\t*x = Model(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\t*x = Model(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=16) "\t\t*x = Model(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=25) "\t\t\treturn _ModelErrNilPtr", + (string) (len=24) "\t\t\treturn errModelNilPtr", (string) (len=3) "\t\t}", (string) (len=26) "\t\t*x, err = ParseModel(*v)", (string) (len=2) "\t}", @@ -1362,22 +1665,181 @@ (string) (len=1) "}", (string) "", (string) (len=7) "const (", + (string) (len=60) "\t// NonASCIIПродам is a NonASCII of type Продам.", + (string) (len=44) "\tNonASCIIПродам NonASCII = iota + 1114", + (string) (len=48) "\t// NonASCII車庫 is a NonASCII of type 車庫.", + (string) (len=37) "\tNonASCII車庫 NonASCII = iota + 299", + (string) (len=52) "\t// NonASCIIԷժան is a NonASCII of type Էժան.", + (string) (len=38) "\tNonASCIIԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=105) "var ErrInvalidNonASCII = fmt.Errorf(\"not a valid NonASCII, try [%s]\", strings.Join(_NonASCIINames, \", \"))", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=30) "var _NonASCIINames = []string{", + (string) (len=21) "\t_NonASCIIName[0:12],", + (string) (len=22) "\t_NonASCIIName[12:18],", + (string) (len=22) "\t_NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=70) "// NonASCIINames returns a list of possible string values of NonASCII.", + (string) (len=31) "func NonASCIINames() []string {", + (string) (len=43) "\ttmp := make([]string, len(_NonASCIINames))", + (string) (len=26) "\tcopy(tmp, _NonASCIINames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=43) "\tNonASCIIПродам: _NonASCIIName[0:12],", + (string) (len=42) "\tNonASCII車庫: _NonASCIIName[12:18],", + (string) (len=42) "\tNonASCIIԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=61) "\t_NonASCIIName[0:12]: NonASCIIПродам,", + (string) (len=61) "\tstrings.ToLower(_NonASCIIName[0:12]): NonASCIIПродам,", + (string) (len=55) "\t_NonASCIIName[12:18]: NonASCII車庫,", + (string) (len=55) "\tstrings.ToLower(_NonASCIIName[12:18]): NonASCII車庫,", + (string) (len=57) "\t_NonASCIIName[18:26]: NonASCIIԷժան,", + (string) (len=57) "\tstrings.ToLower(_NonASCIIName[18:26]): NonASCIIԷժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=56) "\tif x, ok := _NonASCIIValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=94) "var errNonASCIINilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=56) "func (x *NonASCII) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=18) "\t\t*x = NonASCII(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase string:", + (string) (len=28) "\t\t*x, err = ParseNonASCII(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=36) "\t\t*x, err = ParseNonASCII(string(v))", + (string) (len=15) "\tcase NonASCII:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=16) "\tcase *NonASCII:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=29) "\t\t*x, err = ParseNonASCII(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=49) "func (x NonASCII) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", (string) (len=61) "\t// SanitizingTestHyphen is a Sanitizing of type Test-Hyphen.", (string) (len=39) "\tSanitizingTestHyphen Sanitizing = iota", (string) (len=63) "\t// SanitizingHyphenStart is a Sanitizing of type -HyphenStart.", (string) (len=22) "\tSanitizingHyphenStart", - (string) (len=72) "\t// Sanitizing_underscoreFirst is a Sanitizing of type _underscoreFirst.", - (string) (len=27) "\tSanitizing_underscoreFirst", - (string) (len=64) "\t// Sanitizing0numberFirst is a Sanitizing of type 0numberFirst.", - (string) (len=23) "\tSanitizing0numberFirst", - (string) (len=60) "\t// Sanitizing123456789a is a Sanitizing of type 123456789a.", - (string) (len=21) "\tSanitizing123456789a", + (string) (len=72) "\t// Sanitizing_UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=27) "\tSanitizing_UnderscoreFirst", + (string) (len=64) "\t// Sanitizing0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=23) "\tSanitizing0NumberFirst", + (string) (len=60) "\t// Sanitizing123456789A is a Sanitizing of type 123456789A.", + (string) (len=21) "\tSanitizing123456789A", (string) (len=61) "\t// Sanitizing123123Asdf is a Sanitizing of type 123123-Asdf.", (string) (len=21) "\tSanitizing123123Asdf", (string) (len=66) "\t// SanitizingEndingHyphen is a Sanitizing of type Ending-Hyphen-.", (string) (len=23) "\tSanitizingEndingHyphen", (string) (len=1) ")", (string) "", + (string) (len=111) "var ErrInvalidSanitizing = fmt.Errorf(\"not a valid Sanitizing, try [%s]\", strings.Join(_SanitizingNames, \", \"))", + (string) "", (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", (string) "", (string) (len=32) "var _SanitizingNames = []string{", @@ -1398,13 +1860,13 @@ (string) (len=1) "}", (string) "", (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", - (string) (len=26) "\t0: _SanitizingName[0:11],", - (string) (len=27) "\t1: _SanitizingName[11:23],", - (string) (len=27) "\t2: _SanitizingName[23:39],", - (string) (len=27) "\t3: _SanitizingName[39:51],", - (string) (len=27) "\t4: _SanitizingName[51:61],", - (string) (len=27) "\t5: _SanitizingName[61:72],", - (string) (len=27) "\t6: _SanitizingName[72:86],", + (string) (len=51) "\tSanitizingTestHyphen: _SanitizingName[0:11],", + (string) (len=52) "\tSanitizingHyphenStart: _SanitizingName[11:23],", + (string) (len=52) "\tSanitizing_UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=52) "\tSanitizing0NumberFirst: _SanitizingName[39:51],", + (string) (len=52) "\tSanitizing123456789A: _SanitizingName[51:61],", + (string) (len=52) "\tSanitizing123123Asdf: _SanitizingName[61:72],", + (string) (len=52) "\tSanitizingEndingHyphen: _SanitizingName[72:86],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1415,24 +1877,31 @@ (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", - (string) (len=44) "\t_SanitizingName[0:11]: 0,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[0:11]): 0,", - (string) (len=44) "\t_SanitizingName[11:23]: 1,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[11:23]): 1,", - (string) (len=44) "\t_SanitizingName[23:39]: 2,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[23:39]): 2,", - (string) (len=44) "\t_SanitizingName[39:51]: 3,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[39:51]): 3,", - (string) (len=44) "\t_SanitizingName[51:61]: 4,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[51:61]): 4,", - (string) (len=44) "\t_SanitizingName[61:72]: 5,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[61:72]): 5,", - (string) (len=44) "\t_SanitizingName[72:86]: 6,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[72:86]): 6,", - (string) (len=1) "}", - (string) "", - (string) (len=63) "// ParseSanitizing attempts to convert a string to a Sanitizing", + (string) (len=63) "\t_SanitizingName[0:11]: SanitizingTestHyphen,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[0:11]): SanitizingTestHyphen,", + (string) (len=64) "\t_SanitizingName[11:23]: SanitizingHyphenStart,", + (string) (len=64) "\tstrings.ToLower(_SanitizingName[11:23]): SanitizingHyphenStart,", + (string) (len=69) "\t_SanitizingName[23:39]: Sanitizing_UnderscoreFirst,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[23:39]): Sanitizing_UnderscoreFirst,", + (string) (len=65) "\t_SanitizingName[39:51]: Sanitizing0NumberFirst,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[39:51]): Sanitizing0NumberFirst,", + (string) (len=63) "\t_SanitizingName[51:61]: Sanitizing123456789A,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[51:61]): Sanitizing123456789A,", + (string) (len=63) "\t_SanitizingName[61:72]: Sanitizing123123Asdf,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[61:72]): Sanitizing123123Asdf,", + (string) (len=65) "\t_SanitizingName[72:86]: SanitizingEndingHyphen,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[72:86]): SanitizingEndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -1441,15 +1910,15 @@ (string) (len=58) "\tif x, ok := _SanitizingValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=119) "\treturn Sanitizing(0), fmt.Errorf(\"%s is not a valid Sanitizing, try [%s]\", name, strings.Join(_SanitizingNames, \", \"))", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=34) "\ttmp, err := ParseSanitizing(name)", @@ -1460,7 +1929,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=97) "var _SanitizingErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=96) "var errSanitizingNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", @@ -1484,7 +1953,7 @@ (string) (len=20) "\t\t*x = Sanitizing(v)", (string) (len=18) "\tcase *Sanitizing:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1493,34 +1962,34 @@ (string) (len=20) "\t\t*x = Sanitizing(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", (string) (len=3) "\t\t}", (string) (len=21) "\t\t*x = Sanitizing(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", (string) (len=3) "\t\t}", (string) (len=21) "\t\t*x = Sanitizing(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=20) "\t\t*x = Sanitizing(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", (string) (len=3) "\t\t}", (string) (len=21) "\t\t*x = Sanitizing(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", (string) (len=3) "\t\t}", (string) (len=21) "\t\t*x = Sanitizing(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", (string) (len=3) "\t\t}", (string) (len=21) "\t\t*x = Sanitizing(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=30) "\t\t\treturn _SanitizingErrNilPtr", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", (string) (len=3) "\t\t}", (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", (string) (len=2) "\t}", @@ -1542,6 +2011,8 @@ (string) (len=11) "\tSodaMtnDew", (string) (len=1) ")", (string) "", + (string) (len=93) "var ErrInvalidSoda = fmt.Errorf(\"not a valid Soda, try [%s]\", strings.Join(_SodaNames, \", \"))", + (string) "", (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", (string) "", (string) (len=26) "var _SodaNames = []string{", @@ -1558,9 +2029,9 @@ (string) (len=1) "}", (string) "", (string) (len=31) "var _SodaMap = map[Soda]string{", - (string) (len=19) "\t0: _SodaName[0:4],", - (string) (len=19) "\t1: _SodaName[4:9],", - (string) (len=20) "\t2: _SodaName[9:15],", + (string) (len=28) "\tSodaCoke: _SodaName[0:4],", + (string) (len=28) "\tSodaPepsi: _SodaName[4:9],", + (string) (len=29) "\tSodaMtnDew: _SodaName[9:15],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1571,16 +2042,23 @@ (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=33) "var _SodaValue = map[string]Soda{", - (string) (len=37) "\t_SodaName[0:4]: 0,", - (string) (len=37) "\tstrings.ToLower(_SodaName[0:4]): 0,", - (string) (len=37) "\t_SodaName[4:9]: 1,", - (string) (len=37) "\tstrings.ToLower(_SodaName[4:9]): 1,", - (string) (len=37) "\t_SodaName[9:15]: 2,", - (string) (len=37) "\tstrings.ToLower(_SodaName[9:15]): 2,", + (string) (len=44) "\t_SodaName[0:4]: SodaCoke,", + (string) (len=44) "\tstrings.ToLower(_SodaName[0:4]): SodaCoke,", + (string) (len=45) "\t_SodaName[4:9]: SodaPepsi,", + (string) (len=45) "\tstrings.ToLower(_SodaName[4:9]): SodaPepsi,", + (string) (len=46) "\t_SodaName[9:15]: SodaMtnDew,", + (string) (len=46) "\tstrings.ToLower(_SodaName[9:15]): SodaMtnDew,", (string) (len=1) "}", (string) "", - (string) (len=51) "// ParseSoda attempts to convert a string to a Soda", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", (string) (len=43) "func ParseSoda(name string) (Soda, error) {", (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -1589,15 +2067,15 @@ (string) (len=52) "\tif x, ok := _SodaValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=101) "\treturn Soda(0), fmt.Errorf(\"%s is not a valid Soda, try [%s]\", name, strings.Join(_SodaNames, \", \"))", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=28) "\ttmp, err := ParseSoda(name)", @@ -1608,7 +2086,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=91) "var _SodaErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=90) "var errSodaNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=52) "func (x *Soda) Scan(value interface{}) (err error) {", @@ -1632,7 +2110,7 @@ (string) (len=14) "\t\t*x = Soda(v)", (string) (len=12) "\tcase *Soda:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1641,34 +2119,34 @@ (string) (len=14) "\t\t*x = Soda(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=14) "\t\t*x = Soda(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=15) "\t\t*x = Soda(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=24) "\t\t\treturn _SodaErrNilPtr", + (string) (len=23) "\t\t\treturn errSodaNilPtr", (string) (len=3) "\t\t}", (string) (len=25) "\t\t*x, err = ParseSoda(*v)", (string) (len=2) "\t}", @@ -1688,6 +2166,8 @@ (string) (len=20) "\tStartNotZeroNextNum", (string) (len=1) ")", (string) "", + (string) (len=117) "var ErrInvalidStartNotZero = fmt.Errorf(\"not a valid StartNotZero, try [%s]\", strings.Join(_StartNotZeroNames, \", \"))", + (string) "", (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", (string) "", (string) (len=34) "var _StartNotZeroNames = []string{", @@ -1703,8 +2183,8 @@ (string) (len=1) "}", (string) "", (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", - (string) (len=29) "\t23: _StartNotZeroName[0:12],", - (string) (len=30) "\t24: _StartNotZeroName[12:19],", + (string) (len=51) "\tStartNotZeroStartWithNum: _StartNotZeroName[0:12],", + (string) (len=52) "\tStartNotZeroNextNum: _StartNotZeroName[12:19],", (string) (len=1) "}", (string) "", (string) (len=44) "// String implements the Stringer interface.", @@ -1715,14 +2195,21 @@ (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", (string) (len=1) "}", (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", - (string) (len=47) "\t_StartNotZeroName[0:12]: 23,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[0:12]): 23,", - (string) (len=47) "\t_StartNotZeroName[12:19]: 24,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[12:19]): 24,", + (string) (len=69) "\t_StartNotZeroName[0:12]: StartNotZeroStartWithNum,", + (string) (len=69) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartNotZeroStartWithNum,", + (string) (len=64) "\t_StartNotZeroName[12:19]: StartNotZeroNextNum,", + (string) (len=64) "\tstrings.ToLower(_StartNotZeroName[12:19]): StartNotZeroNextNum,", (string) (len=1) "}", (string) "", - (string) (len=67) "// ParseStartNotZero attempts to convert a string to a StartNotZero", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", (string) (len=15) "\t\treturn x, nil", @@ -1731,15 +2218,15 @@ (string) (len=60) "\tif x, ok := _StartNotZeroValue[strings.ToLower(name)]; ok {", (string) (len=15) "\t\treturn x, nil", (string) (len=2) "\t}", - (string) (len=125) "\treturn StartNotZero(0), fmt.Errorf(\"%s is not a valid StartNotZero, try [%s]\", name, strings.Join(_StartNotZeroNames, \", \"))", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", (string) (len=1) "}", (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", + (string) (len=53) "// MarshalText implements the text marshaller method.", (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", (string) (len=31) "\treturn []byte(x.String()), nil", (string) (len=1) "}", (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", (string) (len=21) "\tname := string(text)", (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", @@ -1750,7 +2237,7 @@ (string) (len=11) "\treturn nil", (string) (len=1) "}", (string) "", - (string) (len=99) "var _StartNotZeroErrNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) (len=98) "var errStartNotZeroNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", (string) "", (string) (len=41) "// Scan implements the Scanner interface.", (string) (len=60) "func (x *StartNotZero) Scan(value interface{}) (err error) {", @@ -1774,7 +2261,7 @@ (string) (len=22) "\t\t*x = StartNotZero(v)", (string) (len=20) "\tcase *StartNotZero:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=9) "\t\t*x = *v", (string) (len=11) "\tcase uint:", @@ -1783,34 +2270,34 @@ (string) (len=22) "\t\t*x = StartNotZero(v)", (string) (len=11) "\tcase *int:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=13) "\tcase *int64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", (string) (len=22) "\t\t*x = StartNotZero(v)", (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=12) "\tcase *uint:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=14) "\tcase *uint64:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=23) "\t\t*x = StartNotZero(*v)", (string) (len=14) "\tcase *string:", (string) (len=15) "\t\tif v == nil {", - (string) (len=32) "\t\t\treturn _StartNotZeroErrNilPtr", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", (string) (len=3) "\t\t}", (string) (len=33) "\t\t*x, err = ParseStartNotZero(*v)", (string) (len=2) "\t}", @@ -1822,5 +2309,114 @@ (string) (len=53) "func (x StartNotZero) Value() (driver.Value, error) {", (string) (len=23) "\treturn x.String(), nil", (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// StringEnumRandom is a StringEnum of type random.", + (string) (len=39) "\tStringEnumRandom StringEnum = \"random\"", + (string) (len=52) "\t// StringEnumValues is a StringEnum of type values.", + (string) (len=39) "\tStringEnumValues StringEnum = \"values\"", + (string) (len=48) "\t// StringEnumHere is a StringEnum of type here.", + (string) (len=35) "\tStringEnumHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidStringEnum = fmt.Errorf(\"not a valid StringEnum, try [%s]\", strings.Join(_StringEnumNames, \", \"))", + (string) "", + (string) (len=32) "var _StringEnumNames = []string{", + (string) (len=26) "\tstring(StringEnumRandom),", + (string) (len=26) "\tstring(StringEnumValues),", + (string) (len=24) "\tstring(StringEnumHere),", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// StringEnumNames returns a list of possible string values of StringEnum.", + (string) (len=33) "func StringEnumNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_StringEnumNames))", + (string) (len=28) "\tcopy(tmp, _StringEnumNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=28) "\t\"random\": StringEnumRandom,", + (string) (len=28) "\t\"values\": StringEnumValues,", + (string) (len=26) "\t\"here\": StringEnumHere,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _StringEnumValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errStringEnumNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", (string) "" } diff --git a/generator/.snapshots/Test118ExampleFileMoreOptions-1.18 b/generator/.snapshots/Test118ExampleFileMoreOptions-1.18 new file mode 100644 index 00000000..91e2661c --- /dev/null +++ b/generator/.snapshots/Test118ExampleFileMoreOptions-1.18 @@ -0,0 +1,191 @@ +([]string) (len=189) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// ChangeTypeCreate is a ChangeType of type Create.", + (string) (len=35) "\tChangeTypeCreate ChangeType = iota", + (string) (len=52) "\t// ChangeTypeUpdate is a ChangeType of type Update.", + (string) (len=17) "\tChangeTypeUpdate", + (string) (len=52) "\t// ChangeTypeDelete is a ChangeType of type Delete.", + (string) (len=17) "\tChangeTypeDelete", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidChangeType = fmt.Errorf(\"not a valid ChangeType, try [%s]\", strings.Join(_ChangeTypeNames, \", \"))", + (string) "", + (string) (len=44) "const _ChangeTypeName = \"createupdatedelete\"", + (string) "", + (string) (len=32) "var _ChangeTypeNames = []string{", + (string) (len=22) "\t_ChangeTypeName[0:6],", + (string) (len=23) "\t_ChangeTypeName[6:12],", + (string) (len=24) "\t_ChangeTypeName[12:18],", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// ChangeTypeNames returns a list of possible string values of ChangeType.", + (string) (len=33) "func ChangeTypeNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_ChangeTypeNames))", + (string) (len=28) "\tcopy(tmp, _ChangeTypeNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _ChangeTypeMap = map[ChangeType]string{", + (string) (len=40) "\tChangeTypeCreate: _ChangeTypeName[0:6],", + (string) (len=41) "\tChangeTypeUpdate: _ChangeTypeName[6:12],", + (string) (len=42) "\tChangeTypeDelete: _ChangeTypeName[12:18],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x ChangeType) String() string {", + (string) (len=38) "\tif str, ok := _ChangeTypeMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"ChangeType(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x ChangeType) IsValid() bool {", + (string) (len=27) "\t_, ok := _ChangeTypeMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _ChangeTypeValue = map[string]ChangeType{", + (string) (len=59) "\t_ChangeTypeName[0:6]: ChangeTypeCreate,", + (string) (len=59) "\tstrings.ToLower(_ChangeTypeName[0:6]): ChangeTypeCreate,", + (string) (len=59) "\t_ChangeTypeName[6:12]: ChangeTypeUpdate,", + (string) (len=59) "\tstrings.ToLower(_ChangeTypeName[6:12]): ChangeTypeUpdate,", + (string) (len=59) "\t_ChangeTypeName[12:18]: ChangeTypeDelete,", + (string) (len=59) "\tstrings.ToLower(_ChangeTypeName[12:18]): ChangeTypeDelete,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseChangeType attempts to convert a string to a ChangeType.", + (string) (len=55) "func ParseChangeType(name string) (ChangeType, error) {", + (string) (len=41) "\tif x, ok := _ChangeTypeValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _ChangeTypeValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn ChangeType(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidChangeType)", + (string) (len=1) "}", + (string) "", + (string) (len=85) "// MustParseChangeType converts a string to a ChangeType, and panics if is not valid.", + (string) (len=50) "func MustParseChangeType(name string) ChangeType {", + (string) (len=34) "\tval, err := ParseChangeType(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x ChangeType) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *ChangeType) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseChangeType(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errChangeTypeNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *ChangeType) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = ChangeType(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseChangeType(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseChangeType(string(v))", + (string) (len=17) "\tcase ChangeType:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=18) "\tcase *ChangeType:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = ChangeType(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = ChangeType(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errChangeTypeNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseChangeType(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x ChangeType) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=36) "func ParseChangeTypeExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=42) "func ParseChangeTypeDescription() string {", + (string) (len=50) "\treturn `ChangeType is a type of change detected.`", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/Test118ExampleFileMoreOptions-og b/generator/.snapshots/Test118ExampleFileMoreOptions-og new file mode 100644 index 00000000..598607dc --- /dev/null +++ b/generator/.snapshots/Test118ExampleFileMoreOptions-og @@ -0,0 +1,2660 @@ +([]string) (len=2658) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=38) "\t// AnimalCat is a Animal of type Cat.", + (string) (len=24) "\tAnimalCat Animal = iota", + (string) (len=38) "\t// AnimalDog is a Animal of type Dog.", + (string) (len=10) "\tAnimalDog", + (string) (len=40) "\t// AnimalFish is a Animal of type Fish.", + (string) (len=11) "\tAnimalFish", + (string) (len=1) ")", + (string) "", + (string) (len=99) "var ErrInvalidAnimal = fmt.Errorf(\"not a valid Animal, try [%s]\", strings.Join(_AnimalNames, \", \"))", + (string) "", + (string) (len=32) "const _AnimalName = \"catdogfish\"", + (string) "", + (string) (len=28) "var _AnimalNames = []string{", + (string) (len=18) "\t_AnimalName[0:3],", + (string) (len=18) "\t_AnimalName[3:6],", + (string) (len=19) "\t_AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// AnimalNames returns a list of possible string values of Animal.", + (string) (len=29) "func AnimalNames() []string {", + (string) (len=41) "\ttmp := make([]string, len(_AnimalNames))", + (string) (len=24) "\tcopy(tmp, _AnimalNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=30) "\tAnimalCat: _AnimalName[0:3],", + (string) (len=30) "\tAnimalDog: _AnimalName[3:6],", + (string) (len=31) "\tAnimalFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=47) "\t_AnimalName[0:3]: AnimalCat,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[0:3]): AnimalCat,", + (string) (len=47) "\t_AnimalName[3:6]: AnimalDog,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[3:6]): AnimalDog,", + (string) (len=48) "\t_AnimalName[6:10]: AnimalFish,", + (string) (len=48) "\tstrings.ToLower(_AnimalName[6:10]): AnimalFish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=54) "\tif x, ok := _AnimalValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=77) "// MustParseAnimal converts a string to a Animal, and panics if is not valid.", + (string) (len=42) "func MustParseAnimal(name string) Animal {", + (string) (len=30) "\tval, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=92) "var errAnimalNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=54) "func (x *Animal) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=16) "\t\t*x = Animal(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase string:", + (string) (len=26) "\t\t*x, err = ParseAnimal(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=34) "\t\t*x, err = ParseAnimal(string(v))", + (string) (len=13) "\tcase Animal:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=14) "\tcase *Animal:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x, err = ParseAnimal(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=47) "func (x Animal) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=32) "func ParseAnimalExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=38) "func ParseAnimalDescription() string {", + (string) (len=18) "\treturn `Animal x`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=50) "\t// CasesTest_lower is a Cases of type Test_lower.", + (string) (len=29) "\tCasesTest_lower Cases = iota", + (string) (len=54) "\t// CasesTest_capital is a Cases of type Test_capital.", + (string) (len=18) "\tCasesTest_capital", + (string) (len=72) "\t// CasesAnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=27) "\tCasesAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidCases = fmt.Errorf(\"not a valid Cases, try [%s]\", strings.Join(_CasesNames, \", \"))", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowertest_capitalanotherlowercasestart\"", + (string) "", + (string) (len=27) "var _CasesNames = []string{", + (string) (len=18) "\t_CasesName[0:10],", + (string) (len=19) "\t_CasesName[10:22],", + (string) (len=19) "\t_CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// CasesNames returns a list of possible string values of Cases.", + (string) (len=28) "func CasesNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_CasesNames))", + (string) (len=23) "\tcopy(tmp, _CasesNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=46) "\tCasesTest_lower: _CasesName[0:10],", + (string) (len=47) "\tCasesTest_capital: _CasesName[10:22],", + (string) (len=47) "\tCasesAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=53) "\t_CasesName[0:10]: CasesTest_lower,", + (string) (len=53) "\tstrings.ToLower(_CasesName[0:10]): CasesTest_lower,", + (string) (len=55) "\t_CasesName[10:22]: CasesTest_capital,", + (string) (len=55) "\tstrings.ToLower(_CasesName[10:22]): CasesTest_capital,", + (string) (len=64) "\t_CasesName[22:43]: CasesAnotherLowerCaseStart,", + (string) (len=64) "\tstrings.ToLower(_CasesName[22:43]): CasesAnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _CasesValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseCases converts a string to a Cases, and panics if is not valid.", + (string) (len=40) "func MustParseCases(name string) Cases {", + (string) (len=29) "\tval, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errCasesNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Cases) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Cases(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseCases(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseCases(string(v))", + (string) (len=12) "\tcase Cases:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase *Cases:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseCases(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Cases) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseCasesExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseCasesDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=40) "\t// ColorBlack is a Color of type Black.", + (string) (len=24) "\tColorBlack Color = iota", + (string) (len=40) "\t// ColorWhite is a Color of type White.", + (string) (len=11) "\tColorWhite", + (string) (len=36) "\t// ColorRed is a Color of type Red.", + (string) (len=9) "\tColorRed", + (string) (len=40) "\t// ColorGreen is a Color of type Green.", + (string) (len=11) "\tColorGreen", + (string) (len=38) "\t// ColorBlue is a Color of type Blue.", + (string) (len=28) "\tColorBlue Color = iota + 29", + (string) (len=38) "\t// ColorGrey is a Color of type Grey.", + (string) (len=10) "\tColorGrey", + (string) (len=42) "\t// ColorYellow is a Color of type Yellow.", + (string) (len=12) "\tColorYellow", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidColor = fmt.Errorf(\"not a valid Color, try [%s]\", strings.Join(_ColorNames, \", \"))", + (string) "", + (string) (len=53) "const _ColorName = \"blackwhiteredgreenbluegreyyellow\"", + (string) "", + (string) (len=27) "var _ColorNames = []string{", + (string) (len=17) "\t_ColorName[0:5],", + (string) (len=18) "\t_ColorName[5:10],", + (string) (len=19) "\t_ColorName[10:13],", + (string) (len=19) "\t_ColorName[13:18],", + (string) (len=19) "\t_ColorName[18:22],", + (string) (len=19) "\t_ColorName[22:26],", + (string) (len=19) "\t_ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ColorNames returns a list of possible string values of Color.", + (string) (len=28) "func ColorNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ColorNames))", + (string) (len=23) "\tcopy(tmp, _ColorNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=30) "\tColorBlack: _ColorName[0:5],", + (string) (len=31) "\tColorWhite: _ColorName[5:10],", + (string) (len=32) "\tColorRed: _ColorName[10:13],", + (string) (len=32) "\tColorGreen: _ColorName[13:18],", + (string) (len=32) "\tColorBlue: _ColorName[18:22],", + (string) (len=32) "\tColorGrey: _ColorName[22:26],", + (string) (len=32) "\tColorYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=48) "\t_ColorName[0:5]: ColorBlack,", + (string) (len=48) "\tstrings.ToLower(_ColorName[0:5]): ColorBlack,", + (string) (len=48) "\t_ColorName[5:10]: ColorWhite,", + (string) (len=48) "\tstrings.ToLower(_ColorName[5:10]): ColorWhite,", + (string) (len=46) "\t_ColorName[10:13]: ColorRed,", + (string) (len=46) "\tstrings.ToLower(_ColorName[10:13]): ColorRed,", + (string) (len=48) "\t_ColorName[13:18]: ColorGreen,", + (string) (len=48) "\tstrings.ToLower(_ColorName[13:18]): ColorGreen,", + (string) (len=47) "\t_ColorName[18:22]: ColorBlue,", + (string) (len=47) "\tstrings.ToLower(_ColorName[18:22]): ColorBlue,", + (string) (len=47) "\t_ColorName[22:26]: ColorGrey,", + (string) (len=47) "\tstrings.ToLower(_ColorName[22:26]): ColorGrey,", + (string) (len=49) "\t_ColorName[26:32]: ColorYellow,", + (string) (len=49) "\tstrings.ToLower(_ColorName[26:32]): ColorYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _ColorValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseColor converts a string to a Color, and panics if is not valid.", + (string) (len=40) "func MustParseColor(name string) Color {", + (string) (len=29) "\tval, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errColorNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Color) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Color(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseColor(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseColor(string(v))", + (string) (len=12) "\tcase Color:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase *Color:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseColor(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Color) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseColorExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseColorDescription() string {", + (string) (len=61) "\treturn `Color is an enumeration of colors that are allowed.`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=62) "\t// ColorWithCommentBlack is a ColorWithComment of type Black.", + (string) (len=46) "\tColorWithCommentBlack ColorWithComment = iota", + (string) (len=62) "\t// ColorWithCommentWhite is a ColorWithComment of type White.", + (string) (len=22) "\tColorWithCommentWhite", + (string) (len=58) "\t// ColorWithCommentRed is a ColorWithComment of type Red.", + (string) (len=20) "\tColorWithCommentRed", + (string) (len=62) "\t// ColorWithCommentGreen is a ColorWithComment of type Green.", + (string) (len=22) "\tColorWithCommentGreen", + (string) (len=60) "\t// ColorWithCommentBlue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=50) "\tColorWithCommentBlue ColorWithComment = iota + 29", + (string) (len=60) "\t// ColorWithCommentGrey is a ColorWithComment of type Grey.", + (string) (len=21) "\tColorWithCommentGrey", + (string) (len=64) "\t// ColorWithCommentYellow is a ColorWithComment of type Yellow.", + (string) (len=23) "\tColorWithCommentYellow", + (string) (len=1) ")", + (string) "", + (string) (len=129) "var ErrInvalidColorWithComment = fmt.Errorf(\"not a valid ColorWithComment, try [%s]\", strings.Join(_ColorWithCommentNames, \", \"))", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"blackwhiteredgreenbluegreyyellow\"", + (string) "", + (string) (len=38) "var _ColorWithCommentNames = []string{", + (string) (len=28) "\t_ColorWithCommentName[0:5],", + (string) (len=29) "\t_ColorWithCommentName[5:10],", + (string) (len=30) "\t_ColorWithCommentName[10:13],", + (string) (len=30) "\t_ColorWithCommentName[13:18],", + (string) (len=30) "\t_ColorWithCommentName[18:22],", + (string) (len=30) "\t_ColorWithCommentName[22:26],", + (string) (len=30) "\t_ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=86) "// ColorWithCommentNames returns a list of possible string values of ColorWithComment.", + (string) (len=39) "func ColorWithCommentNames() []string {", + (string) (len=51) "\ttmp := make([]string, len(_ColorWithCommentNames))", + (string) (len=34) "\tcopy(tmp, _ColorWithCommentNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=52) "\tColorWithCommentBlack: _ColorWithCommentName[0:5],", + (string) (len=53) "\tColorWithCommentWhite: _ColorWithCommentName[5:10],", + (string) (len=54) "\tColorWithCommentRed: _ColorWithCommentName[10:13],", + (string) (len=54) "\tColorWithCommentGreen: _ColorWithCommentName[13:18],", + (string) (len=54) "\tColorWithCommentBlue: _ColorWithCommentName[18:22],", + (string) (len=54) "\tColorWithCommentGrey: _ColorWithCommentName[22:26],", + (string) (len=54) "\tColorWithCommentYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=70) "\t_ColorWithCommentName[0:5]: ColorWithCommentBlack,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[0:5]): ColorWithCommentBlack,", + (string) (len=70) "\t_ColorWithCommentName[5:10]: ColorWithCommentWhite,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[5:10]): ColorWithCommentWhite,", + (string) (len=68) "\t_ColorWithCommentName[10:13]: ColorWithCommentRed,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[10:13]): ColorWithCommentRed,", + (string) (len=70) "\t_ColorWithCommentName[13:18]: ColorWithCommentGreen,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[13:18]): ColorWithCommentGreen,", + (string) (len=69) "\t_ColorWithCommentName[18:22]: ColorWithCommentBlue,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[18:22]): ColorWithCommentBlue,", + (string) (len=69) "\t_ColorWithCommentName[22:26]: ColorWithCommentGrey,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[22:26]): ColorWithCommentGrey,", + (string) (len=71) "\t_ColorWithCommentName[26:32]: ColorWithCommentYellow,", + (string) (len=71) "\tstrings.ToLower(_ColorWithCommentName[26:32]): ColorWithCommentYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=64) "\tif x, ok := _ColorWithCommentValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=97) "// MustParseColorWithComment converts a string to a ColorWithComment, and panics if is not valid.", + (string) (len=62) "func MustParseColorWithComment(name string) ColorWithComment {", + (string) (len=40) "\tval, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=102) "var errColorWithCommentNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=64) "func (x *ColorWithComment) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=26) "\t\t*x = ColorWithComment(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase string:", + (string) (len=36) "\t\t*x, err = ParseColorWithComment(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=44) "\t\t*x, err = ParseColorWithComment(string(v))", + (string) (len=23) "\tcase ColorWithComment:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=24) "\tcase *ColorWithComment:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=37) "\t\t*x, err = ParseColorWithComment(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x ColorWithComment) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=42) "func ParseColorWithCommentExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=48) "func ParseColorWithCommentDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment2Black is a ColorWithComment2 of type Black.", + (string) (len=48) "\tColorWithComment2Black ColorWithComment2 = iota", + (string) (len=64) "\t// ColorWithComment2White is a ColorWithComment2 of type White.", + (string) (len=23) "\tColorWithComment2White", + (string) (len=60) "\t// ColorWithComment2Red is a ColorWithComment2 of type Red.", + (string) (len=21) "\tColorWithComment2Red", + (string) (len=64) "\t// ColorWithComment2Green is a ColorWithComment2 of type Green.", + (string) (len=23) "\tColorWithComment2Green", + (string) (len=62) "\t// ColorWithComment2Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=52) "\tColorWithComment2Blue ColorWithComment2 = iota + 29", + (string) (len=62) "\t// ColorWithComment2Grey is a ColorWithComment2 of type Grey.", + (string) (len=22) "\tColorWithComment2Grey", + (string) (len=66) "\t// ColorWithComment2Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=24) "\tColorWithComment2Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment2 = fmt.Errorf(\"not a valid ColorWithComment2, try [%s]\", strings.Join(_ColorWithComment2Names, \", \"))", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"blackwhiteredgreenbluegreyyellow\"", + (string) "", + (string) (len=39) "var _ColorWithComment2Names = []string{", + (string) (len=29) "\t_ColorWithComment2Name[0:5],", + (string) (len=30) "\t_ColorWithComment2Name[5:10],", + (string) (len=31) "\t_ColorWithComment2Name[10:13],", + (string) (len=31) "\t_ColorWithComment2Name[13:18],", + (string) (len=31) "\t_ColorWithComment2Name[18:22],", + (string) (len=31) "\t_ColorWithComment2Name[22:26],", + (string) (len=31) "\t_ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment2Names returns a list of possible string values of ColorWithComment2.", + (string) (len=40) "func ColorWithComment2Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment2Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment2Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=54) "\tColorWithComment2Black: _ColorWithComment2Name[0:5],", + (string) (len=55) "\tColorWithComment2White: _ColorWithComment2Name[5:10],", + (string) (len=56) "\tColorWithComment2Red: _ColorWithComment2Name[10:13],", + (string) (len=56) "\tColorWithComment2Green: _ColorWithComment2Name[13:18],", + (string) (len=56) "\tColorWithComment2Blue: _ColorWithComment2Name[18:22],", + (string) (len=56) "\tColorWithComment2Grey: _ColorWithComment2Name[22:26],", + (string) (len=56) "\tColorWithComment2Yellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=72) "\t_ColorWithComment2Name[0:5]: ColorWithComment2Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): ColorWithComment2Black,", + (string) (len=72) "\t_ColorWithComment2Name[5:10]: ColorWithComment2White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): ColorWithComment2White,", + (string) (len=70) "\t_ColorWithComment2Name[10:13]: ColorWithComment2Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): ColorWithComment2Red,", + (string) (len=72) "\t_ColorWithComment2Name[13:18]: ColorWithComment2Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): ColorWithComment2Green,", + (string) (len=71) "\t_ColorWithComment2Name[18:22]: ColorWithComment2Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): ColorWithComment2Blue,", + (string) (len=71) "\t_ColorWithComment2Name[22:26]: ColorWithComment2Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): ColorWithComment2Grey,", + (string) (len=73) "\t_ColorWithComment2Name[26:32]: ColorWithComment2Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): ColorWithComment2Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment2Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment2 converts a string to a ColorWithComment2, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment2(name string) ColorWithComment2 {", + (string) (len=41) "\tval, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment2NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment2) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment2(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment2(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment2(string(v))", + (string) (len=24) "\tcase ColorWithComment2:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=25) "\tcase *ColorWithComment2:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment2(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment2) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment2Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment2Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment3Black is a ColorWithComment3 of type Black.", + (string) (len=48) "\tColorWithComment3Black ColorWithComment3 = iota", + (string) (len=64) "\t// ColorWithComment3White is a ColorWithComment3 of type White.", + (string) (len=23) "\tColorWithComment3White", + (string) (len=60) "\t// ColorWithComment3Red is a ColorWithComment3 of type Red.", + (string) (len=21) "\tColorWithComment3Red", + (string) (len=64) "\t// ColorWithComment3Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment3Green ColorWithComment3 = iota + 30", + (string) (len=62) "\t// ColorWithComment3Blue is a ColorWithComment3 of type Blue.", + (string) (len=22) "\tColorWithComment3Blue", + (string) (len=62) "\t// ColorWithComment3Grey is a ColorWithComment3 of type Grey.", + (string) (len=22) "\tColorWithComment3Grey", + (string) (len=66) "\t// ColorWithComment3Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=24) "\tColorWithComment3Yellow", + (string) (len=73) "\t// ColorWithComment3BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment3BlueGreen", + (string) (len=73) "\t// ColorWithComment3RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=27) "\tColorWithComment3RedOrange", + (string) (len=82) "\t// ColorWithComment3RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=31) "\tColorWithComment3RedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment3 = fmt.Errorf(\"not a valid ColorWithComment3, try [%s]\", strings.Join(_ColorWithComment3Names, \", \"))", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"blackwhiteredgreenbluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=39) "var _ColorWithComment3Names = []string{", + (string) (len=29) "\t_ColorWithComment3Name[0:5],", + (string) (len=30) "\t_ColorWithComment3Name[5:10],", + (string) (len=31) "\t_ColorWithComment3Name[10:13],", + (string) (len=31) "\t_ColorWithComment3Name[13:18],", + (string) (len=31) "\t_ColorWithComment3Name[18:22],", + (string) (len=31) "\t_ColorWithComment3Name[22:26],", + (string) (len=31) "\t_ColorWithComment3Name[26:32],", + (string) (len=31) "\t_ColorWithComment3Name[32:42],", + (string) (len=31) "\t_ColorWithComment3Name[42:52],", + (string) (len=31) "\t_ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment3Names returns a list of possible string values of ColorWithComment3.", + (string) (len=40) "func ColorWithComment3Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment3Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment3Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=61) "\tColorWithComment3Black: _ColorWithComment3Name[0:5],", + (string) (len=62) "\tColorWithComment3White: _ColorWithComment3Name[5:10],", + (string) (len=63) "\tColorWithComment3Red: _ColorWithComment3Name[10:13],", + (string) (len=63) "\tColorWithComment3Green: _ColorWithComment3Name[13:18],", + (string) (len=63) "\tColorWithComment3Blue: _ColorWithComment3Name[18:22],", + (string) (len=63) "\tColorWithComment3Grey: _ColorWithComment3Name[22:26],", + (string) (len=63) "\tColorWithComment3Yellow: _ColorWithComment3Name[26:32],", + (string) (len=63) "\tColorWithComment3BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=63) "\tColorWithComment3RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=63) "\tColorWithComment3RedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=72) "\t_ColorWithComment3Name[0:5]: ColorWithComment3Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): ColorWithComment3Black,", + (string) (len=72) "\t_ColorWithComment3Name[5:10]: ColorWithComment3White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): ColorWithComment3White,", + (string) (len=70) "\t_ColorWithComment3Name[10:13]: ColorWithComment3Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): ColorWithComment3Red,", + (string) (len=72) "\t_ColorWithComment3Name[13:18]: ColorWithComment3Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): ColorWithComment3Green,", + (string) (len=71) "\t_ColorWithComment3Name[18:22]: ColorWithComment3Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): ColorWithComment3Blue,", + (string) (len=71) "\t_ColorWithComment3Name[22:26]: ColorWithComment3Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): ColorWithComment3Grey,", + (string) (len=73) "\t_ColorWithComment3Name[26:32]: ColorWithComment3Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): ColorWithComment3Yellow,", + (string) (len=76) "\t_ColorWithComment3Name[32:42]: ColorWithComment3BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): ColorWithComment3BlueGreen,", + (string) (len=76) "\t_ColorWithComment3Name[42:52]: ColorWithComment3RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): ColorWithComment3RedOrange,", + (string) (len=80) "\t_ColorWithComment3Name[52:67]: ColorWithComment3RedOrangeBlue,", + (string) (len=80) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): ColorWithComment3RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment3Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment3 converts a string to a ColorWithComment3, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment3(name string) ColorWithComment3 {", + (string) (len=41) "\tval, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment3NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment3) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment3(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment3(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment3(string(v))", + (string) (len=24) "\tcase ColorWithComment3:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=25) "\tcase *ColorWithComment3:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment3(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment3) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment3Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment3Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=64) "\t// ColorWithComment4Black is a ColorWithComment4 of type Black.", + (string) (len=23) "\tColorWithComment4Black", + (string) (len=64) "\t// ColorWithComment4White is a ColorWithComment4 of type White.", + (string) (len=23) "\tColorWithComment4White", + (string) (len=60) "\t// ColorWithComment4Red is a ColorWithComment4 of type Red.", + (string) (len=21) "\tColorWithComment4Red", + (string) (len=64) "\t// ColorWithComment4Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment4Green ColorWithComment4 = iota + 29", + (string) (len=62) "\t// ColorWithComment4Blue is a ColorWithComment4 of type Blue.", + (string) (len=22) "\tColorWithComment4Blue", + (string) (len=62) "\t// ColorWithComment4Grey is a ColorWithComment4 of type Grey.", + (string) (len=22) "\tColorWithComment4Grey", + (string) (len=66) "\t// ColorWithComment4Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=24) "\tColorWithComment4Yellow", + (string) (len=73) "\t// ColorWithComment4BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment4BlueGreen", + (string) (len=73) "\t// ColorWithComment4RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=27) "\tColorWithComment4RedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment4 = fmt.Errorf(\"not a valid ColorWithComment4, try [%s]\", strings.Join(_ColorWithComment4Names, \", \"))", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"blackwhiteredgreenbluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=39) "var _ColorWithComment4Names = []string{", + (string) (len=29) "\t_ColorWithComment4Name[0:5],", + (string) (len=30) "\t_ColorWithComment4Name[5:10],", + (string) (len=31) "\t_ColorWithComment4Name[10:13],", + (string) (len=31) "\t_ColorWithComment4Name[13:18],", + (string) (len=31) "\t_ColorWithComment4Name[18:22],", + (string) (len=31) "\t_ColorWithComment4Name[22:26],", + (string) (len=31) "\t_ColorWithComment4Name[26:32],", + (string) (len=31) "\t_ColorWithComment4Name[32:42],", + (string) (len=31) "\t_ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment4Names returns a list of possible string values of ColorWithComment4.", + (string) (len=40) "func ColorWithComment4Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment4Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment4Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=57) "\tColorWithComment4Black: _ColorWithComment4Name[0:5],", + (string) (len=58) "\tColorWithComment4White: _ColorWithComment4Name[5:10],", + (string) (len=59) "\tColorWithComment4Red: _ColorWithComment4Name[10:13],", + (string) (len=59) "\tColorWithComment4Green: _ColorWithComment4Name[13:18],", + (string) (len=59) "\tColorWithComment4Blue: _ColorWithComment4Name[18:22],", + (string) (len=59) "\tColorWithComment4Grey: _ColorWithComment4Name[22:26],", + (string) (len=59) "\tColorWithComment4Yellow: _ColorWithComment4Name[26:32],", + (string) (len=59) "\tColorWithComment4BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=59) "\tColorWithComment4RedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=72) "\t_ColorWithComment4Name[0:5]: ColorWithComment4Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): ColorWithComment4Black,", + (string) (len=72) "\t_ColorWithComment4Name[5:10]: ColorWithComment4White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): ColorWithComment4White,", + (string) (len=70) "\t_ColorWithComment4Name[10:13]: ColorWithComment4Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): ColorWithComment4Red,", + (string) (len=72) "\t_ColorWithComment4Name[13:18]: ColorWithComment4Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): ColorWithComment4Green,", + (string) (len=71) "\t_ColorWithComment4Name[18:22]: ColorWithComment4Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): ColorWithComment4Blue,", + (string) (len=71) "\t_ColorWithComment4Name[22:26]: ColorWithComment4Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): ColorWithComment4Grey,", + (string) (len=73) "\t_ColorWithComment4Name[26:32]: ColorWithComment4Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): ColorWithComment4Yellow,", + (string) (len=76) "\t_ColorWithComment4Name[32:42]: ColorWithComment4BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): ColorWithComment4BlueGreen,", + (string) (len=76) "\t_ColorWithComment4Name[42:52]: ColorWithComment4RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): ColorWithComment4RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment4Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment4 converts a string to a ColorWithComment4, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment4(name string) ColorWithComment4 {", + (string) (len=41) "\tval, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment4NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment4) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment4(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment4(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment4(string(v))", + (string) (len=24) "\tcase ColorWithComment4:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=25) "\tcase *ColorWithComment4:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment4(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment4) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment4Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment4Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Enum64bitUnknown is a Enum64bit of type Unknown.", + (string) (len=34) "\tEnum64bitUnknown Enum64bit = iota", + (string) (len=48) "\t// Enum64bitE2P15 is a Enum64bit of type E2P15.", + (string) (len=40) "\tEnum64bitE2P15 Enum64bit = iota + 32767", + (string) (len=48) "\t// Enum64bitE2P16 is a Enum64bit of type E2P16.", + (string) (len=40) "\tEnum64bitE2P16 Enum64bit = iota + 65534", + (string) (len=48) "\t// Enum64bitE2P17 is a Enum64bit of type E2P17.", + (string) (len=41) "\tEnum64bitE2P17 Enum64bit = iota + 131069", + (string) (len=48) "\t// Enum64bitE2P18 is a Enum64bit of type E2P18.", + (string) (len=41) "\tEnum64bitE2P18 Enum64bit = iota + 262140", + (string) (len=48) "\t// Enum64bitE2P19 is a Enum64bit of type E2P19.", + (string) (len=41) "\tEnum64bitE2P19 Enum64bit = iota + 524283", + (string) (len=48) "\t// Enum64bitE2P20 is a Enum64bit of type E2P20.", + (string) (len=42) "\tEnum64bitE2P20 Enum64bit = iota + 1048570", + (string) (len=48) "\t// Enum64bitE2P21 is a Enum64bit of type E2P21.", + (string) (len=42) "\tEnum64bitE2P21 Enum64bit = iota + 2097145", + (string) (len=48) "\t// Enum64bitE2P22 is a Enum64bit of type E2P22.", + (string) (len=43) "\tEnum64bitE2P22 Enum64bit = iota + 33554424", + (string) (len=48) "\t// Enum64bitE2P23 is a Enum64bit of type E2P23.", + (string) (len=43) "\tEnum64bitE2P23 Enum64bit = iota + 67108855", + (string) (len=48) "\t// Enum64bitE2P28 is a Enum64bit of type E2P28.", + (string) (len=44) "\tEnum64bitE2P28 Enum64bit = iota + 536870902", + (string) (len=48) "\t// Enum64bitE2P30 is a Enum64bit of type E2P30.", + (string) (len=45) "\tEnum64bitE2P30 Enum64bit = iota + 1073741813", + (string) (len=48) "\t// Enum64bitE2P31 is a Enum64bit of type E2P31.", + (string) (len=45) "\tEnum64bitE2P31 Enum64bit = iota + 2147483636", + (string) (len=48) "\t// Enum64bitE2P32 is a Enum64bit of type E2P32.", + (string) (len=45) "\tEnum64bitE2P32 Enum64bit = iota + 4294967283", + (string) (len=48) "\t// Enum64bitE2P33 is a Enum64bit of type E2P33.", + (string) (len=45) "\tEnum64bitE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=108) "var ErrInvalidEnum64bit = fmt.Errorf(\"not a valid Enum64bit, try [%s]\", strings.Join(_Enum64bitNames, \", \"))", + (string) "", + (string) (len=102) "const _Enum64bitName = \"unknowne2p15e2p16e2p17e2p18e2p19e2p20e2p21e2p22e2p23e2p28e2p30e2p31e2p32e2p33\"", + (string) "", + (string) (len=31) "var _Enum64bitNames = []string{", + (string) (len=21) "\t_Enum64bitName[0:7],", + (string) (len=22) "\t_Enum64bitName[7:12],", + (string) (len=23) "\t_Enum64bitName[12:17],", + (string) (len=23) "\t_Enum64bitName[17:22],", + (string) (len=23) "\t_Enum64bitName[22:27],", + (string) (len=23) "\t_Enum64bitName[27:32],", + (string) (len=23) "\t_Enum64bitName[32:37],", + (string) (len=23) "\t_Enum64bitName[37:42],", + (string) (len=23) "\t_Enum64bitName[42:47],", + (string) (len=23) "\t_Enum64bitName[47:52],", + (string) (len=23) "\t_Enum64bitName[52:57],", + (string) (len=23) "\t_Enum64bitName[57:62],", + (string) (len=23) "\t_Enum64bitName[62:67],", + (string) (len=23) "\t_Enum64bitName[67:72],", + (string) (len=23) "\t_Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=72) "// Enum64bitNames returns a list of possible string values of Enum64bit.", + (string) (len=32) "func Enum64bitNames() []string {", + (string) (len=44) "\ttmp := make([]string, len(_Enum64bitNames))", + (string) (len=27) "\tcopy(tmp, _Enum64bitNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=39) "\tEnum64bitUnknown: _Enum64bitName[0:7],", + (string) (len=40) "\tEnum64bitE2P15: _Enum64bitName[7:12],", + (string) (len=41) "\tEnum64bitE2P16: _Enum64bitName[12:17],", + (string) (len=41) "\tEnum64bitE2P17: _Enum64bitName[17:22],", + (string) (len=41) "\tEnum64bitE2P18: _Enum64bitName[22:27],", + (string) (len=41) "\tEnum64bitE2P19: _Enum64bitName[27:32],", + (string) (len=41) "\tEnum64bitE2P20: _Enum64bitName[32:37],", + (string) (len=41) "\tEnum64bitE2P21: _Enum64bitName[37:42],", + (string) (len=41) "\tEnum64bitE2P22: _Enum64bitName[42:47],", + (string) (len=41) "\tEnum64bitE2P23: _Enum64bitName[47:52],", + (string) (len=41) "\tEnum64bitE2P28: _Enum64bitName[52:57],", + (string) (len=41) "\tEnum64bitE2P30: _Enum64bitName[57:62],", + (string) (len=41) "\tEnum64bitE2P31: _Enum64bitName[62:67],", + (string) (len=41) "\tEnum64bitE2P32: _Enum64bitName[67:72],", + (string) (len=41) "\tEnum64bitE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=58) "\t_Enum64bitName[0:7]: Enum64bitUnknown,", + (string) (len=58) "\tstrings.ToLower(_Enum64bitName[0:7]): Enum64bitUnknown,", + (string) (len=56) "\t_Enum64bitName[7:12]: Enum64bitE2P15,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[7:12]): Enum64bitE2P15,", + (string) (len=56) "\t_Enum64bitName[12:17]: Enum64bitE2P16,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[12:17]): Enum64bitE2P16,", + (string) (len=56) "\t_Enum64bitName[17:22]: Enum64bitE2P17,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[17:22]): Enum64bitE2P17,", + (string) (len=56) "\t_Enum64bitName[22:27]: Enum64bitE2P18,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[22:27]): Enum64bitE2P18,", + (string) (len=56) "\t_Enum64bitName[27:32]: Enum64bitE2P19,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[27:32]): Enum64bitE2P19,", + (string) (len=56) "\t_Enum64bitName[32:37]: Enum64bitE2P20,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[32:37]): Enum64bitE2P20,", + (string) (len=56) "\t_Enum64bitName[37:42]: Enum64bitE2P21,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[37:42]): Enum64bitE2P21,", + (string) (len=56) "\t_Enum64bitName[42:47]: Enum64bitE2P22,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[42:47]): Enum64bitE2P22,", + (string) (len=56) "\t_Enum64bitName[47:52]: Enum64bitE2P23,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[47:52]): Enum64bitE2P23,", + (string) (len=56) "\t_Enum64bitName[52:57]: Enum64bitE2P28,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[52:57]): Enum64bitE2P28,", + (string) (len=56) "\t_Enum64bitName[57:62]: Enum64bitE2P30,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[57:62]): Enum64bitE2P30,", + (string) (len=56) "\t_Enum64bitName[62:67]: Enum64bitE2P31,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[62:67]): Enum64bitE2P31,", + (string) (len=56) "\t_Enum64bitName[67:72]: Enum64bitE2P32,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[67:72]): Enum64bitE2P32,", + (string) (len=56) "\t_Enum64bitName[72:77]: Enum64bitE2P33,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[72:77]): Enum64bitE2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=57) "\tif x, ok := _Enum64bitValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=83) "// MustParseEnum64bit converts a string to a Enum64bit, and panics if is not valid.", + (string) (len=48) "func MustParseEnum64bit(name string) Enum64bit {", + (string) (len=33) "\tval, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=95) "var errEnum64bitNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *Enum64bit) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=19) "\t\t*x = Enum64bit(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase string:", + (string) (len=29) "\t\t*x, err = ParseEnum64bit(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=37) "\t\t*x, err = ParseEnum64bit(string(v))", + (string) (len=16) "\tcase Enum64bit:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=17) "\tcase *Enum64bit:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=30) "\t\t*x, err = ParseEnum64bit(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x Enum64bit) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=35) "func ParseEnum64bitExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=41) "func ParseEnum64bitDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// ModelToyota is a Model of type Toyota.", + (string) (len=25) "\tModelToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=40) "\t// ModelChevy is a Model of type Chevy.", + (string) (len=11) "\tModelChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=38) "\t// ModelFord is a Model of type Ford.", + (string) (len=10) "\tModelFord", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidModel = fmt.Errorf(\"not a valid Model, try [%s]\", strings.Join(_ModelNames, \", \"))", + (string) "", + (string) (len=36) "const _ModelName = \"toyotachevyford\"", + (string) "", + (string) (len=27) "var _ModelNames = []string{", + (string) (len=17) "\t_ModelName[0:6],", + (string) (len=18) "\t_ModelName[6:11],", + (string) (len=19) "\t_ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ModelNames returns a list of possible string values of Model.", + (string) (len=28) "func ModelNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ModelNames))", + (string) (len=23) "\tcopy(tmp, _ModelNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=30) "\tModelToyota: _ModelName[0:6],", + (string) (len=31) "\tModelChevy: _ModelName[6:11],", + (string) (len=32) "\tModelFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=49) "\t_ModelName[0:6]: ModelToyota,", + (string) (len=49) "\tstrings.ToLower(_ModelName[0:6]): ModelToyota,", + (string) (len=48) "\t_ModelName[6:11]: ModelChevy,", + (string) (len=48) "\tstrings.ToLower(_ModelName[6:11]): ModelChevy,", + (string) (len=47) "\t_ModelName[11:15]: ModelFord,", + (string) (len=47) "\tstrings.ToLower(_ModelName[11:15]): ModelFord,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _ModelValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseModel converts a string to a Model, and panics if is not valid.", + (string) (len=40) "func MustParseModel(name string) Model {", + (string) (len=29) "\tval, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errModelNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Model) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Model(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseModel(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseModel(string(v))", + (string) (len=12) "\tcase Model:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase *Model:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseModel(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Model) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseModelExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseModelDescription() string {", + (string) (len=17) "\treturn `Model x`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=60) "\t// NonASCIIПродам is a NonASCII of type Продам.", + (string) (len=44) "\tNonASCIIПродам NonASCII = iota + 1114", + (string) (len=48) "\t// NonASCII車庫 is a NonASCII of type 車庫.", + (string) (len=37) "\tNonASCII車庫 NonASCII = iota + 299", + (string) (len=52) "\t// NonASCIIԷժան is a NonASCII of type Էժան.", + (string) (len=38) "\tNonASCIIԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=105) "var ErrInvalidNonASCII = fmt.Errorf(\"not a valid NonASCII, try [%s]\", strings.Join(_NonASCIINames, \", \"))", + (string) "", + (string) (len=50) "const _NonASCIIName = \"продам車庫էժան\"", + (string) "", + (string) (len=30) "var _NonASCIINames = []string{", + (string) (len=21) "\t_NonASCIIName[0:12],", + (string) (len=22) "\t_NonASCIIName[12:18],", + (string) (len=22) "\t_NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=70) "// NonASCIINames returns a list of possible string values of NonASCII.", + (string) (len=31) "func NonASCIINames() []string {", + (string) (len=43) "\ttmp := make([]string, len(_NonASCIINames))", + (string) (len=26) "\tcopy(tmp, _NonASCIINames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=43) "\tNonASCIIПродам: _NonASCIIName[0:12],", + (string) (len=42) "\tNonASCII車庫: _NonASCIIName[12:18],", + (string) (len=42) "\tNonASCIIԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=61) "\t_NonASCIIName[0:12]: NonASCIIПродам,", + (string) (len=61) "\tstrings.ToLower(_NonASCIIName[0:12]): NonASCIIПродам,", + (string) (len=55) "\t_NonASCIIName[12:18]: NonASCII車庫,", + (string) (len=55) "\tstrings.ToLower(_NonASCIIName[12:18]): NonASCII車庫,", + (string) (len=57) "\t_NonASCIIName[18:26]: NonASCIIԷժան,", + (string) (len=57) "\tstrings.ToLower(_NonASCIIName[18:26]): NonASCIIԷժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=56) "\tif x, ok := _NonASCIIValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=81) "// MustParseNonASCII converts a string to a NonASCII, and panics if is not valid.", + (string) (len=46) "func MustParseNonASCII(name string) NonASCII {", + (string) (len=32) "\tval, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=94) "var errNonASCIINilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=56) "func (x *NonASCII) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=18) "\t\t*x = NonASCII(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase string:", + (string) (len=28) "\t\t*x, err = ParseNonASCII(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=36) "\t\t*x, err = ParseNonASCII(string(v))", + (string) (len=15) "\tcase NonASCII:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=16) "\tcase *NonASCII:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=29) "\t\t*x, err = ParseNonASCII(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=49) "func (x NonASCII) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=34) "func ParseNonASCIIExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=40) "func ParseNonASCIIDescription() string {", + (string) (len=18) "\treturn `NonASCII`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=61) "\t// SanitizingTestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=39) "\tSanitizingTestHyphen Sanitizing = iota", + (string) (len=63) "\t// SanitizingHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=22) "\tSanitizingHyphenStart", + (string) (len=72) "\t// Sanitizing_UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=27) "\tSanitizing_UnderscoreFirst", + (string) (len=64) "\t// Sanitizing0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=23) "\tSanitizing0NumberFirst", + (string) (len=60) "\t// Sanitizing123456789A is a Sanitizing of type 123456789A.", + (string) (len=21) "\tSanitizing123456789A", + (string) (len=61) "\t// Sanitizing123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=21) "\tSanitizing123123Asdf", + (string) (len=66) "\t// SanitizingEndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=23) "\tSanitizingEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidSanitizing = fmt.Errorf(\"not a valid Sanitizing, try [%s]\", strings.Join(_SanitizingNames, \", \"))", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-hyphen-hyphenstart_underscorefirst0numberfirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=32) "var _SanitizingNames = []string{", + (string) (len=23) "\t_SanitizingName[0:11],", + (string) (len=24) "\t_SanitizingName[11:23],", + (string) (len=24) "\t_SanitizingName[23:39],", + (string) (len=24) "\t_SanitizingName[39:51],", + (string) (len=24) "\t_SanitizingName[51:61],", + (string) (len=24) "\t_SanitizingName[61:72],", + (string) (len=24) "\t_SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// SanitizingNames returns a list of possible string values of Sanitizing.", + (string) (len=33) "func SanitizingNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_SanitizingNames))", + (string) (len=28) "\tcopy(tmp, _SanitizingNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=51) "\tSanitizingTestHyphen: _SanitizingName[0:11],", + (string) (len=52) "\tSanitizingHyphenStart: _SanitizingName[11:23],", + (string) (len=52) "\tSanitizing_UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=52) "\tSanitizing0NumberFirst: _SanitizingName[39:51],", + (string) (len=52) "\tSanitizing123456789A: _SanitizingName[51:61],", + (string) (len=52) "\tSanitizing123123Asdf: _SanitizingName[61:72],", + (string) (len=52) "\tSanitizingEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=63) "\t_SanitizingName[0:11]: SanitizingTestHyphen,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[0:11]): SanitizingTestHyphen,", + (string) (len=64) "\t_SanitizingName[11:23]: SanitizingHyphenStart,", + (string) (len=64) "\tstrings.ToLower(_SanitizingName[11:23]): SanitizingHyphenStart,", + (string) (len=69) "\t_SanitizingName[23:39]: Sanitizing_UnderscoreFirst,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[23:39]): Sanitizing_UnderscoreFirst,", + (string) (len=65) "\t_SanitizingName[39:51]: Sanitizing0NumberFirst,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[39:51]): Sanitizing0NumberFirst,", + (string) (len=63) "\t_SanitizingName[51:61]: Sanitizing123456789A,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[51:61]): Sanitizing123456789A,", + (string) (len=63) "\t_SanitizingName[61:72]: Sanitizing123123Asdf,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[61:72]): Sanitizing123123Asdf,", + (string) (len=65) "\t_SanitizingName[72:86]: SanitizingEndingHyphen,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[72:86]): SanitizingEndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _SanitizingValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=85) "// MustParseSanitizing converts a string to a Sanitizing, and panics if is not valid.", + (string) (len=50) "func MustParseSanitizing(name string) Sanitizing {", + (string) (len=34) "\tval, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errSanitizingNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = Sanitizing(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseSanitizing(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseSanitizing(string(v))", + (string) (len=17) "\tcase Sanitizing:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\tcase *Sanitizing:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x Sanitizing) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=36) "func ParseSanitizingExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=42) "func ParseSanitizingDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=36) "\t// SodaCoke is a Soda of type Coke.", + (string) (len=21) "\tSodaCoke Soda = iota", + (string) (len=38) "\t// SodaPepsi is a Soda of type Pepsi.", + (string) (len=10) "\tSodaPepsi", + (string) (len=40) "\t// SodaMtnDew is a Soda of type MtnDew.", + (string) (len=11) "\tSodaMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=93) "var ErrInvalidSoda = fmt.Errorf(\"not a valid Soda, try [%s]\", strings.Join(_SodaNames, \", \"))", + (string) "", + (string) (len=35) "const _SodaName = \"cokepepsimtndew\"", + (string) "", + (string) (len=26) "var _SodaNames = []string{", + (string) (len=16) "\t_SodaName[0:4],", + (string) (len=16) "\t_SodaName[4:9],", + (string) (len=17) "\t_SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// SodaNames returns a list of possible string values of Soda.", + (string) (len=27) "func SodaNames() []string {", + (string) (len=39) "\ttmp := make([]string, len(_SodaNames))", + (string) (len=22) "\tcopy(tmp, _SodaNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=28) "\tSodaCoke: _SodaName[0:4],", + (string) (len=28) "\tSodaPepsi: _SodaName[4:9],", + (string) (len=29) "\tSodaMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=44) "\t_SodaName[0:4]: SodaCoke,", + (string) (len=44) "\tstrings.ToLower(_SodaName[0:4]): SodaCoke,", + (string) (len=45) "\t_SodaName[4:9]: SodaPepsi,", + (string) (len=45) "\tstrings.ToLower(_SodaName[4:9]): SodaPepsi,", + (string) (len=46) "\t_SodaName[9:15]: SodaMtnDew,", + (string) (len=46) "\tstrings.ToLower(_SodaName[9:15]): SodaMtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=52) "\tif x, ok := _SodaValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=73) "// MustParseSoda converts a string to a Soda, and panics if is not valid.", + (string) (len=38) "func MustParseSoda(name string) Soda {", + (string) (len=28) "\tval, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=90) "var errSodaNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=52) "func (x *Soda) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=14) "\t\t*x = Soda(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase string:", + (string) (len=24) "\t\t*x, err = ParseSoda(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=32) "\t\t*x, err = ParseSoda(string(v))", + (string) (len=11) "\tcase Soda:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=12) "\tcase *Soda:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=25) "\t\t*x, err = ParseSoda(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=45) "func (x Soda) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=30) "func ParseSodaExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=36) "func ParseSodaDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=68) "\t// StartNotZeroStartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=50) "\tStartNotZeroStartWithNum StartNotZero = iota + 23", + (string) (len=58) "\t// StartNotZeroNextNum is a StartNotZero of type NextNum.", + (string) (len=20) "\tStartNotZeroNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=117) "var ErrInvalidStartNotZero = fmt.Errorf(\"not a valid StartNotZero, try [%s]\", strings.Join(_StartNotZeroNames, \", \"))", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startwithnumnextnum\"", + (string) "", + (string) (len=34) "var _StartNotZeroNames = []string{", + (string) (len=25) "\t_StartNotZeroName[0:12],", + (string) (len=26) "\t_StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// StartNotZeroNames returns a list of possible string values of StartNotZero.", + (string) (len=35) "func StartNotZeroNames() []string {", + (string) (len=47) "\ttmp := make([]string, len(_StartNotZeroNames))", + (string) (len=30) "\tcopy(tmp, _StartNotZeroNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=51) "\tStartNotZeroStartWithNum: _StartNotZeroName[0:12],", + (string) (len=52) "\tStartNotZeroNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=69) "\t_StartNotZeroName[0:12]: StartNotZeroStartWithNum,", + (string) (len=69) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartNotZeroStartWithNum,", + (string) (len=64) "\t_StartNotZeroName[12:19]: StartNotZeroNextNum,", + (string) (len=64) "\tstrings.ToLower(_StartNotZeroName[12:19]): StartNotZeroNextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=60) "\tif x, ok := _StartNotZeroValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=89) "// MustParseStartNotZero converts a string to a StartNotZero, and panics if is not valid.", + (string) (len=54) "func MustParseStartNotZero(name string) StartNotZero {", + (string) (len=36) "\tval, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=98) "var errStartNotZeroNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=60) "func (x *StartNotZero) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=22) "\t\t*x = StartNotZero(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase string:", + (string) (len=32) "\t\t*x, err = ParseStartNotZero(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=40) "\t\t*x, err = ParseStartNotZero(string(v))", + (string) (len=19) "\tcase StartNotZero:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=20) "\tcase *StartNotZero:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=33) "\t\t*x, err = ParseStartNotZero(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x StartNotZero) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=38) "func ParseStartNotZeroExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=44) "func ParseStartNotZeroDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// StringEnumRandom is a StringEnum of type random.", + (string) (len=39) "\tStringEnumRandom StringEnum = \"random\"", + (string) (len=52) "\t// StringEnumValues is a StringEnum of type values.", + (string) (len=39) "\tStringEnumValues StringEnum = \"values\"", + (string) (len=48) "\t// StringEnumHere is a StringEnum of type here.", + (string) (len=35) "\tStringEnumHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidStringEnum = fmt.Errorf(\"not a valid StringEnum, try [%s]\", strings.Join(_StringEnumNames, \", \"))", + (string) "", + (string) (len=32) "var _StringEnumNames = []string{", + (string) (len=26) "\tstring(StringEnumRandom),", + (string) (len=26) "\tstring(StringEnumValues),", + (string) (len=24) "\tstring(StringEnumHere),", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// StringEnumNames returns a list of possible string values of StringEnum.", + (string) (len=33) "func StringEnumNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_StringEnumNames))", + (string) (len=28) "\tcopy(tmp, _StringEnumNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=28) "\t\"random\": StringEnumRandom,", + (string) (len=28) "\t\"values\": StringEnumValues,", + (string) (len=26) "\t\"here\": StringEnumHere,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _StringEnumValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=85) "// MustParseStringEnum converts a string to a StringEnum, and panics if is not valid.", + (string) (len=50) "func MustParseStringEnum(name string) StringEnum {", + (string) (len=34) "\tval, err := ParseStringEnum(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errStringEnumNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=36) "func ParseStringEnumExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=42) "func ParseStringEnumDescription() string {", + (string) (len=21) "\treturn `StringEnum.`", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/Test118NoPrefixExampleFile-1.18 b/generator/.snapshots/Test118NoPrefixExampleFile-1.18 new file mode 100644 index 00000000..b51e97e4 --- /dev/null +++ b/generator/.snapshots/Test118NoPrefixExampleFile-1.18 @@ -0,0 +1,100 @@ +([]string) (len=98) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// Create is a ChangeType of type Create.", + (string) (len=25) "\tCreate ChangeType = iota", + (string) (len=42) "\t// Update is a ChangeType of type Update.", + (string) (len=7) "\tUpdate", + (string) (len=42) "\t// Delete is a ChangeType of type Delete.", + (string) (len=7) "\tDelete", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidChangeType = errors.New(\"not a valid ChangeType\")", + (string) "", + (string) (len=44) "const _ChangeTypeName = \"CreateUpdateDelete\"", + (string) "", + (string) (len=43) "var _ChangeTypeMap = map[ChangeType]string{", + (string) (len=30) "\tCreate: _ChangeTypeName[0:6],", + (string) (len=31) "\tUpdate: _ChangeTypeName[6:12],", + (string) (len=32) "\tDelete: _ChangeTypeName[12:18],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x ChangeType) String() string {", + (string) (len=38) "\tif str, ok := _ChangeTypeMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"ChangeType(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x ChangeType) IsValid() bool {", + (string) (len=27) "\t_, ok := _ChangeTypeMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _ChangeTypeValue = map[string]ChangeType{", + (string) (len=49) "\t_ChangeTypeName[0:6]: Create,", + (string) (len=49) "\tstrings.ToLower(_ChangeTypeName[0:6]): Create,", + (string) (len=49) "\t_ChangeTypeName[6:12]: Update,", + (string) (len=49) "\tstrings.ToLower(_ChangeTypeName[6:12]): Update,", + (string) (len=49) "\t_ChangeTypeName[12:18]: Delete,", + (string) (len=49) "\tstrings.ToLower(_ChangeTypeName[12:18]): Delete,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseChangeType attempts to convert a string to a ChangeType.", + (string) (len=55) "func ParseChangeType(name string) (ChangeType, error) {", + (string) (len=41) "\tif x, ok := _ChangeTypeValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn ChangeType(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidChangeType)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x ChangeType) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *ChangeType) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseChangeType(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *ChangeType) Set(val string) error {", + (string) (len=31) "\tv, err := ParseChangeType(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *ChangeType) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *ChangeType) Type() string {", + (string) (len=20) "\treturn \"ChangeType\"", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/Test118NoPrefixExampleFile-og b/generator/.snapshots/Test118NoPrefixExampleFile-og new file mode 100644 index 00000000..4df6e5c1 --- /dev/null +++ b/generator/.snapshots/Test118NoPrefixExampleFile-og @@ -0,0 +1,1392 @@ +([]string) (len=1390) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Cat is a Animal of type Cat.", + (string) (len=18) "\tCat Animal = iota", + (string) (len=32) "\t// Dog is a Animal of type Dog.", + (string) (len=4) "\tDog", + (string) (len=34) "\t// Fish is a Animal of type Fish.", + (string) (len=5) "\tFish", + (string) (len=1) ")", + (string) "", + (string) (len=55) "var ErrInvalidAnimal = errors.New(\"not a valid Animal\")", + (string) "", + (string) (len=32) "const _AnimalName = \"CatDogFish\"", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=24) "\tCat: _AnimalName[0:3],", + (string) (len=24) "\tDog: _AnimalName[3:6],", + (string) (len=25) "\tFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=41) "\t_AnimalName[0:3]: Cat,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[0:3]): Cat,", + (string) (len=41) "\t_AnimalName[3:6]: Dog,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[3:6]): Dog,", + (string) (len=42) "\t_AnimalName[6:10]: Fish,", + (string) (len=42) "\tstrings.ToLower(_AnimalName[6:10]): Fish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=40) "func (x *Animal) Set(val string) error {", + (string) (len=27) "\tv, err := ParseAnimal(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=36) "func (x *Animal) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=32) "func (x *Animal) Type() string {", + (string) (len=16) "\treturn \"Animal\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=45) "\t// Test_lower is a Cases of type Test_lower.", + (string) (len=24) "\tTest_lower Cases = iota", + (string) (len=49) "\t// Test_capital is a Cases of type Test_capital.", + (string) (len=13) "\tTest_capital", + (string) (len=67) "\t// AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=22) "\tAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidCases = errors.New(\"not a valid Cases\")", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=41) "\tTest_lower: _CasesName[0:10],", + (string) (len=42) "\tTest_capital: _CasesName[10:22],", + (string) (len=42) "\tAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=48) "\t_CasesName[0:10]: Test_lower,", + (string) (len=48) "\tstrings.ToLower(_CasesName[0:10]): Test_lower,", + (string) (len=50) "\t_CasesName[10:22]: Test_capital,", + (string) (len=50) "\tstrings.ToLower(_CasesName[10:22]): Test_capital,", + (string) (len=59) "\t_CasesName[22:43]: AnotherLowerCaseStart,", + (string) (len=59) "\tstrings.ToLower(_CasesName[22:43]): AnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Cases) Set(val string) error {", + (string) (len=26) "\tv, err := ParseCases(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Cases) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Cases) Type() string {", + (string) (len=15) "\treturn \"Cases\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=35) "\t// Black is a Color of type Black.", + (string) (len=19) "\tBlack Color = iota", + (string) (len=35) "\t// White is a Color of type White.", + (string) (len=6) "\tWhite", + (string) (len=31) "\t// Red is a Color of type Red.", + (string) (len=4) "\tRed", + (string) (len=35) "\t// Green is a Color of type Green.", + (string) (len=6) "\tGreen", + (string) (len=33) "\t// Blue is a Color of type Blue.", + (string) (len=23) "\tBlue Color = iota + 29", + (string) (len=33) "\t// Grey is a Color of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=37) "\t// Yellow is a Color of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidColor = errors.New(\"not a valid Color\")", + (string) "", + (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=25) "\tBlack: _ColorName[0:5],", + (string) (len=26) "\tWhite: _ColorName[5:10],", + (string) (len=27) "\tRed: _ColorName[10:13],", + (string) (len=27) "\tGreen: _ColorName[13:18],", + (string) (len=27) "\tBlue: _ColorName[18:22],", + (string) (len=27) "\tGrey: _ColorName[22:26],", + (string) (len=27) "\tYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=43) "\t_ColorName[0:5]: Black,", + (string) (len=43) "\tstrings.ToLower(_ColorName[0:5]): Black,", + (string) (len=43) "\t_ColorName[5:10]: White,", + (string) (len=43) "\tstrings.ToLower(_ColorName[5:10]): White,", + (string) (len=41) "\t_ColorName[10:13]: Red,", + (string) (len=41) "\tstrings.ToLower(_ColorName[10:13]): Red,", + (string) (len=43) "\t_ColorName[13:18]: Green,", + (string) (len=43) "\tstrings.ToLower(_ColorName[13:18]): Green,", + (string) (len=42) "\t_ColorName[18:22]: Blue,", + (string) (len=42) "\tstrings.ToLower(_ColorName[18:22]): Blue,", + (string) (len=42) "\t_ColorName[22:26]: Grey,", + (string) (len=42) "\tstrings.ToLower(_ColorName[22:26]): Grey,", + (string) (len=44) "\t_ColorName[26:32]: Yellow,", + (string) (len=44) "\tstrings.ToLower(_ColorName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Color) Set(val string) error {", + (string) (len=26) "\tv, err := ParseColor(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Color) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Color) Type() string {", + (string) (len=15) "\treturn \"Color\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=46) "\t// Black is a ColorWithComment of type Black.", + (string) (len=30) "\tBlack ColorWithComment = iota", + (string) (len=46) "\t// White is a ColorWithComment of type White.", + (string) (len=6) "\tWhite", + (string) (len=42) "\t// Red is a ColorWithComment of type Red.", + (string) (len=4) "\tRed", + (string) (len=46) "\t// Green is a ColorWithComment of type Green.", + (string) (len=6) "\tGreen", + (string) (len=44) "\t// Blue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=34) "\tBlue ColorWithComment = iota + 29", + (string) (len=44) "\t// Grey is a ColorWithComment of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=48) "\t// Yellow is a ColorWithComment of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=75) "var ErrInvalidColorWithComment = errors.New(\"not a valid ColorWithComment\")", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=36) "\tBlack: _ColorWithCommentName[0:5],", + (string) (len=37) "\tWhite: _ColorWithCommentName[5:10],", + (string) (len=38) "\tRed: _ColorWithCommentName[10:13],", + (string) (len=38) "\tGreen: _ColorWithCommentName[13:18],", + (string) (len=38) "\tBlue: _ColorWithCommentName[18:22],", + (string) (len=38) "\tGrey: _ColorWithCommentName[22:26],", + (string) (len=38) "\tYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=54) "\t_ColorWithCommentName[0:5]: Black,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[0:5]): Black,", + (string) (len=54) "\t_ColorWithCommentName[5:10]: White,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[5:10]): White,", + (string) (len=52) "\t_ColorWithCommentName[10:13]: Red,", + (string) (len=52) "\tstrings.ToLower(_ColorWithCommentName[10:13]): Red,", + (string) (len=54) "\t_ColorWithCommentName[13:18]: Green,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[13:18]): Green,", + (string) (len=53) "\t_ColorWithCommentName[18:22]: Blue,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[18:22]): Blue,", + (string) (len=53) "\t_ColorWithCommentName[22:26]: Grey,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[22:26]): Grey,", + (string) (len=55) "\t_ColorWithCommentName[26:32]: Yellow,", + (string) (len=55) "\tstrings.ToLower(_ColorWithCommentName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", + (string) (len=37) "\tv, err := ParseColorWithComment(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=42) "func (x *ColorWithComment) Type() string {", + (string) (len=26) "\treturn \"ColorWithComment\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment2 of type Black.", + (string) (len=31) "\tBlack ColorWithComment2 = iota", + (string) (len=47) "\t// White is a ColorWithComment2 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment2 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment2 of type Green.", + (string) (len=6) "\tGreen", + (string) (len=45) "\t// Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=35) "\tBlue ColorWithComment2 = iota + 29", + (string) (len=45) "\t// Grey is a ColorWithComment2 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment2 = errors.New(\"not a valid ColorWithComment2\")", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=37) "\tBlack: _ColorWithComment2Name[0:5],", + (string) (len=38) "\tWhite: _ColorWithComment2Name[5:10],", + (string) (len=39) "\tRed: _ColorWithComment2Name[10:13],", + (string) (len=39) "\tGreen: _ColorWithComment2Name[13:18],", + (string) (len=39) "\tBlue: _ColorWithComment2Name[18:22],", + (string) (len=39) "\tGrey: _ColorWithComment2Name[22:26],", + (string) (len=39) "\tYellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=55) "\t_ColorWithComment2Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment2Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment2Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment2Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment2Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment2Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment2Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment2(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment2) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment2\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment3 of type Black.", + (string) (len=31) "\tBlack ColorWithComment3 = iota", + (string) (len=47) "\t// White is a ColorWithComment3 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment3 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment3 = iota + 30", + (string) (len=45) "\t// Blue is a ColorWithComment3 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment3 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=10) "\tRedOrange", + (string) (len=65) "\t// RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=14) "\tRedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment3 = errors.New(\"not a valid ColorWithComment3\")", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=44) "\tBlack: _ColorWithComment3Name[0:5],", + (string) (len=45) "\tWhite: _ColorWithComment3Name[5:10],", + (string) (len=46) "\tRed: _ColorWithComment3Name[10:13],", + (string) (len=46) "\tGreen: _ColorWithComment3Name[13:18],", + (string) (len=46) "\tBlue: _ColorWithComment3Name[18:22],", + (string) (len=46) "\tGrey: _ColorWithComment3Name[22:26],", + (string) (len=46) "\tYellow: _ColorWithComment3Name[26:32],", + (string) (len=46) "\tBlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=46) "\tRedOrange: _ColorWithComment3Name[42:52],", + (string) (len=46) "\tRedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=55) "\t_ColorWithComment3Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment3Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment3Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment3Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment3Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment3Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment3Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment3Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment3Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): RedOrange,", + (string) (len=63) "\t_ColorWithComment3Name[52:67]: RedOrangeBlue,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment3(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment3) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment3\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=47) "\t// Black is a ColorWithComment4 of type Black.", + (string) (len=6) "\tBlack", + (string) (len=47) "\t// White is a ColorWithComment4 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment4 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment4 = iota + 29", + (string) (len=45) "\t// Blue is a ColorWithComment4 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment4 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=10) "\tRedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment4 = errors.New(\"not a valid ColorWithComment4\")", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=40) "\tBlack: _ColorWithComment4Name[0:5],", + (string) (len=41) "\tWhite: _ColorWithComment4Name[5:10],", + (string) (len=42) "\tRed: _ColorWithComment4Name[10:13],", + (string) (len=42) "\tGreen: _ColorWithComment4Name[13:18],", + (string) (len=42) "\tBlue: _ColorWithComment4Name[18:22],", + (string) (len=42) "\tGrey: _ColorWithComment4Name[22:26],", + (string) (len=42) "\tYellow: _ColorWithComment4Name[26:32],", + (string) (len=42) "\tBlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=42) "\tRedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=55) "\t_ColorWithComment4Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment4Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment4Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment4Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment4Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment4Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment4Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment4Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment4Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment4(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment4) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment4\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=43) "\t// Unknown is a Enum64bit of type Unknown.", + (string) (len=25) "\tUnknown Enum64bit = iota", + (string) (len=39) "\t// E2P15 is a Enum64bit of type E2P15.", + (string) (len=31) "\tE2P15 Enum64bit = iota + 32767", + (string) (len=39) "\t// E2P16 is a Enum64bit of type E2P16.", + (string) (len=31) "\tE2P16 Enum64bit = iota + 65534", + (string) (len=39) "\t// E2P17 is a Enum64bit of type E2P17.", + (string) (len=32) "\tE2P17 Enum64bit = iota + 131069", + (string) (len=39) "\t// E2P18 is a Enum64bit of type E2P18.", + (string) (len=32) "\tE2P18 Enum64bit = iota + 262140", + (string) (len=39) "\t// E2P19 is a Enum64bit of type E2P19.", + (string) (len=32) "\tE2P19 Enum64bit = iota + 524283", + (string) (len=39) "\t// E2P20 is a Enum64bit of type E2P20.", + (string) (len=33) "\tE2P20 Enum64bit = iota + 1048570", + (string) (len=39) "\t// E2P21 is a Enum64bit of type E2P21.", + (string) (len=33) "\tE2P21 Enum64bit = iota + 2097145", + (string) (len=39) "\t// E2P22 is a Enum64bit of type E2P22.", + (string) (len=34) "\tE2P22 Enum64bit = iota + 33554424", + (string) (len=39) "\t// E2P23 is a Enum64bit of type E2P23.", + (string) (len=34) "\tE2P23 Enum64bit = iota + 67108855", + (string) (len=39) "\t// E2P28 is a Enum64bit of type E2P28.", + (string) (len=35) "\tE2P28 Enum64bit = iota + 536870902", + (string) (len=39) "\t// E2P30 is a Enum64bit of type E2P30.", + (string) (len=36) "\tE2P30 Enum64bit = iota + 1073741813", + (string) (len=39) "\t// E2P31 is a Enum64bit of type E2P31.", + (string) (len=36) "\tE2P31 Enum64bit = iota + 2147483636", + (string) (len=39) "\t// E2P32 is a Enum64bit of type E2P32.", + (string) (len=36) "\tE2P32 Enum64bit = iota + 4294967283", + (string) (len=39) "\t// E2P33 is a Enum64bit of type E2P33.", + (string) (len=36) "\tE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=61) "var ErrInvalidEnum64bit = errors.New(\"not a valid Enum64bit\")", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=30) "\tUnknown: _Enum64bitName[0:7],", + (string) (len=31) "\tE2P15: _Enum64bitName[7:12],", + (string) (len=32) "\tE2P16: _Enum64bitName[12:17],", + (string) (len=32) "\tE2P17: _Enum64bitName[17:22],", + (string) (len=32) "\tE2P18: _Enum64bitName[22:27],", + (string) (len=32) "\tE2P19: _Enum64bitName[27:32],", + (string) (len=32) "\tE2P20: _Enum64bitName[32:37],", + (string) (len=32) "\tE2P21: _Enum64bitName[37:42],", + (string) (len=32) "\tE2P22: _Enum64bitName[42:47],", + (string) (len=32) "\tE2P23: _Enum64bitName[47:52],", + (string) (len=32) "\tE2P28: _Enum64bitName[52:57],", + (string) (len=32) "\tE2P30: _Enum64bitName[57:62],", + (string) (len=32) "\tE2P31: _Enum64bitName[62:67],", + (string) (len=32) "\tE2P32: _Enum64bitName[67:72],", + (string) (len=32) "\tE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=49) "\t_Enum64bitName[0:7]: Unknown,", + (string) (len=49) "\tstrings.ToLower(_Enum64bitName[0:7]): Unknown,", + (string) (len=47) "\t_Enum64bitName[7:12]: E2P15,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[7:12]): E2P15,", + (string) (len=47) "\t_Enum64bitName[12:17]: E2P16,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[12:17]): E2P16,", + (string) (len=47) "\t_Enum64bitName[17:22]: E2P17,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[17:22]): E2P17,", + (string) (len=47) "\t_Enum64bitName[22:27]: E2P18,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[22:27]): E2P18,", + (string) (len=47) "\t_Enum64bitName[27:32]: E2P19,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[27:32]): E2P19,", + (string) (len=47) "\t_Enum64bitName[32:37]: E2P20,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[32:37]): E2P20,", + (string) (len=47) "\t_Enum64bitName[37:42]: E2P21,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[37:42]): E2P21,", + (string) (len=47) "\t_Enum64bitName[42:47]: E2P22,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[42:47]): E2P22,", + (string) (len=47) "\t_Enum64bitName[47:52]: E2P23,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[47:52]): E2P23,", + (string) (len=47) "\t_Enum64bitName[52:57]: E2P28,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[52:57]): E2P28,", + (string) (len=47) "\t_Enum64bitName[57:62]: E2P30,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[57:62]): E2P30,", + (string) (len=47) "\t_Enum64bitName[62:67]: E2P31,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[62:67]): E2P31,", + (string) (len=47) "\t_Enum64bitName[67:72]: E2P32,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[67:72]): E2P32,", + (string) (len=47) "\t_Enum64bitName[72:77]: E2P33,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[72:77]): E2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=43) "func (x *Enum64bit) Set(val string) error {", + (string) (len=30) "\tv, err := ParseEnum64bit(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=39) "func (x *Enum64bit) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=35) "func (x *Enum64bit) Type() string {", + (string) (len=19) "\treturn \"Enum64bit\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=37) "\t// Toyota is a Model of type Toyota.", + (string) (len=20) "\tToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=35) "\t// Chevy is a Model of type Chevy.", + (string) (len=6) "\tChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=33) "\t// Ford is a Model of type Ford.", + (string) (len=5) "\tFord", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidModel = errors.New(\"not a valid Model\")", + (string) "", + (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=25) "\tToyota: _ModelName[0:6],", + (string) (len=26) "\tChevy: _ModelName[6:11],", + (string) (len=27) "\tFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=44) "\t_ModelName[0:6]: Toyota,", + (string) (len=44) "\tstrings.ToLower(_ModelName[0:6]): Toyota,", + (string) (len=43) "\t_ModelName[6:11]: Chevy,", + (string) (len=43) "\tstrings.ToLower(_ModelName[6:11]): Chevy,", + (string) (len=42) "\t_ModelName[11:15]: Ford,", + (string) (len=42) "\tstrings.ToLower(_ModelName[11:15]): Ford,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Model) Set(val string) error {", + (string) (len=26) "\tv, err := ParseModel(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Model) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Model) Type() string {", + (string) (len=15) "\treturn \"Model\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Продам is a NonASCII of type Продам.", + (string) (len=36) "\tПродам NonASCII = iota + 1114", + (string) (len=40) "\t// 車庫 is a NonASCII of type 車庫.", + (string) (len=29) "\t車庫 NonASCII = iota + 299", + (string) (len=44) "\t// Էժան is a NonASCII of type Էժան.", + (string) (len=30) "\tԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=59) "var ErrInvalidNonASCII = errors.New(\"not a valid NonASCII\")", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=35) "\tПродам: _NonASCIIName[0:12],", + (string) (len=34) "\t車庫: _NonASCIIName[12:18],", + (string) (len=34) "\tԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=53) "\t_NonASCIIName[0:12]: Продам,", + (string) (len=53) "\tstrings.ToLower(_NonASCIIName[0:12]): Продам,", + (string) (len=47) "\t_NonASCIIName[12:18]: 車庫,", + (string) (len=47) "\tstrings.ToLower(_NonASCIIName[12:18]): 車庫,", + (string) (len=49) "\t_NonASCIIName[18:26]: Էժան,", + (string) (len=49) "\tstrings.ToLower(_NonASCIIName[18:26]): Էժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=42) "func (x *NonASCII) Set(val string) error {", + (string) (len=29) "\tv, err := ParseNonASCII(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=38) "func (x *NonASCII) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=34) "func (x *NonASCII) Type() string {", + (string) (len=18) "\treturn \"NonASCII\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=51) "\t// TestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=29) "\tTestHyphen Sanitizing = iota", + (string) (len=54) "\t// XHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=13) "\tXHyphenStart", + (string) (len=63) "\t// X_UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=18) "\tX_UnderscoreFirst", + (string) (len=55) "\t// X0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=14) "\tX0NumberFirst", + (string) (len=51) "\t// X123456789A is a Sanitizing of type 123456789A.", + (string) (len=12) "\tX123456789A", + (string) (len=52) "\t// X123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=12) "\tX123123Asdf", + (string) (len=56) "\t// EndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=13) "\tEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidSanitizing = errors.New(\"not a valid Sanitizing\")", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=42) "\tTestHyphen: _SanitizingName[0:11],", + (string) (len=43) "\tXHyphenStart: _SanitizingName[11:23],", + (string) (len=43) "\tX_UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=43) "\tX0NumberFirst: _SanitizingName[39:51],", + (string) (len=43) "\tX123456789A: _SanitizingName[51:61],", + (string) (len=43) "\tX123123Asdf: _SanitizingName[61:72],", + (string) (len=43) "\tEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=53) "\t_SanitizingName[0:11]: TestHyphen,", + (string) (len=53) "\tstrings.ToLower(_SanitizingName[0:11]): TestHyphen,", + (string) (len=55) "\t_SanitizingName[11:23]: XHyphenStart,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[11:23]): XHyphenStart,", + (string) (len=60) "\t_SanitizingName[23:39]: X_UnderscoreFirst,", + (string) (len=60) "\tstrings.ToLower(_SanitizingName[23:39]): X_UnderscoreFirst,", + (string) (len=56) "\t_SanitizingName[39:51]: X0NumberFirst,", + (string) (len=56) "\tstrings.ToLower(_SanitizingName[39:51]): X0NumberFirst,", + (string) (len=54) "\t_SanitizingName[51:61]: X123456789A,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[51:61]): X123456789A,", + (string) (len=54) "\t_SanitizingName[61:72]: X123123Asdf,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[61:72]): X123123Asdf,", + (string) (len=55) "\t_SanitizingName[72:86]: EndingHyphen,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[72:86]): EndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *Sanitizing) Set(val string) error {", + (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *Sanitizing) Type() string {", + (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Coke is a Soda of type Coke.", + (string) (len=17) "\tCoke Soda = iota", + (string) (len=34) "\t// Pepsi is a Soda of type Pepsi.", + (string) (len=6) "\tPepsi", + (string) (len=36) "\t// MtnDew is a Soda of type MtnDew.", + (string) (len=7) "\tMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=51) "var ErrInvalidSoda = errors.New(\"not a valid Soda\")", + (string) "", + (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=24) "\tCoke: _SodaName[0:4],", + (string) (len=24) "\tPepsi: _SodaName[4:9],", + (string) (len=25) "\tMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=40) "\t_SodaName[0:4]: Coke,", + (string) (len=40) "\tstrings.ToLower(_SodaName[0:4]): Coke,", + (string) (len=41) "\t_SodaName[4:9]: Pepsi,", + (string) (len=41) "\tstrings.ToLower(_SodaName[4:9]): Pepsi,", + (string) (len=42) "\t_SodaName[9:15]: MtnDew,", + (string) (len=42) "\tstrings.ToLower(_SodaName[9:15]): MtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=38) "func (x *Soda) Set(val string) error {", + (string) (len=25) "\tv, err := ParseSoda(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=34) "func (x *Soda) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=30) "func (x *Soda) Type() string {", + (string) (len=14) "\treturn \"Soda\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// StartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=38) "\tStartWithNum StartNotZero = iota + 23", + (string) (len=46) "\t// NextNum is a StartNotZero of type NextNum.", + (string) (len=8) "\tNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=67) "var ErrInvalidStartNotZero = errors.New(\"not a valid StartNotZero\")", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=39) "\tStartWithNum: _StartNotZeroName[0:12],", + (string) (len=40) "\tNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=57) "\t_StartNotZeroName[0:12]: StartWithNum,", + (string) (len=57) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartWithNum,", + (string) (len=52) "\t_StartNotZeroName[12:19]: NextNum,", + (string) (len=52) "\tstrings.ToLower(_StartNotZeroName[12:19]): NextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=46) "func (x *StartNotZero) Set(val string) error {", + (string) (len=33) "\tv, err := ParseStartNotZero(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=42) "func (x *StartNotZero) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=38) "func (x *StartNotZero) Type() string {", + (string) (len=22) "\treturn \"StartNotZero\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// Random is a StringEnum of type random.", + (string) (len=29) "\tRandom StringEnum = \"random\"", + (string) (len=42) "\t// Values is a StringEnum of type values.", + (string) (len=29) "\tValues StringEnum = \"values\"", + (string) (len=38) "\t// Here is a StringEnum of type here.", + (string) (len=25) "\tHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidStringEnum = errors.New(\"not a valid StringEnum\")", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=18) "\t\"random\": Random,", + (string) (len=18) "\t\"values\": Values,", + (string) (len=16) "\t\"here\": Here,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *StringEnum) Set(val string) error {", + (string) (len=31) "\tv, err := ParseStringEnum(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *StringEnum) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *StringEnum) Type() string {", + (string) (len=20) "\treturn \"StringEnum\"", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/Test118NoPrefixExampleFileWithSnakeToCamel-1.18 b/generator/.snapshots/Test118NoPrefixExampleFileWithSnakeToCamel-1.18 new file mode 100644 index 00000000..b51e97e4 --- /dev/null +++ b/generator/.snapshots/Test118NoPrefixExampleFileWithSnakeToCamel-1.18 @@ -0,0 +1,100 @@ +([]string) (len=98) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// Create is a ChangeType of type Create.", + (string) (len=25) "\tCreate ChangeType = iota", + (string) (len=42) "\t// Update is a ChangeType of type Update.", + (string) (len=7) "\tUpdate", + (string) (len=42) "\t// Delete is a ChangeType of type Delete.", + (string) (len=7) "\tDelete", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidChangeType = errors.New(\"not a valid ChangeType\")", + (string) "", + (string) (len=44) "const _ChangeTypeName = \"CreateUpdateDelete\"", + (string) "", + (string) (len=43) "var _ChangeTypeMap = map[ChangeType]string{", + (string) (len=30) "\tCreate: _ChangeTypeName[0:6],", + (string) (len=31) "\tUpdate: _ChangeTypeName[6:12],", + (string) (len=32) "\tDelete: _ChangeTypeName[12:18],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x ChangeType) String() string {", + (string) (len=38) "\tif str, ok := _ChangeTypeMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"ChangeType(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x ChangeType) IsValid() bool {", + (string) (len=27) "\t_, ok := _ChangeTypeMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _ChangeTypeValue = map[string]ChangeType{", + (string) (len=49) "\t_ChangeTypeName[0:6]: Create,", + (string) (len=49) "\tstrings.ToLower(_ChangeTypeName[0:6]): Create,", + (string) (len=49) "\t_ChangeTypeName[6:12]: Update,", + (string) (len=49) "\tstrings.ToLower(_ChangeTypeName[6:12]): Update,", + (string) (len=49) "\t_ChangeTypeName[12:18]: Delete,", + (string) (len=49) "\tstrings.ToLower(_ChangeTypeName[12:18]): Delete,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseChangeType attempts to convert a string to a ChangeType.", + (string) (len=55) "func ParseChangeType(name string) (ChangeType, error) {", + (string) (len=41) "\tif x, ok := _ChangeTypeValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn ChangeType(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidChangeType)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x ChangeType) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *ChangeType) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseChangeType(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *ChangeType) Set(val string) error {", + (string) (len=31) "\tv, err := ParseChangeType(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *ChangeType) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *ChangeType) Type() string {", + (string) (len=20) "\treturn \"ChangeType\"", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/Test118NoPrefixExampleFileWithSnakeToCamel-og b/generator/.snapshots/Test118NoPrefixExampleFileWithSnakeToCamel-og new file mode 100644 index 00000000..82a21133 --- /dev/null +++ b/generator/.snapshots/Test118NoPrefixExampleFileWithSnakeToCamel-og @@ -0,0 +1,1392 @@ +([]string) (len=1390) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Cat is a Animal of type Cat.", + (string) (len=18) "\tCat Animal = iota", + (string) (len=32) "\t// Dog is a Animal of type Dog.", + (string) (len=4) "\tDog", + (string) (len=34) "\t// Fish is a Animal of type Fish.", + (string) (len=5) "\tFish", + (string) (len=1) ")", + (string) "", + (string) (len=55) "var ErrInvalidAnimal = errors.New(\"not a valid Animal\")", + (string) "", + (string) (len=32) "const _AnimalName = \"CatDogFish\"", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=24) "\tCat: _AnimalName[0:3],", + (string) (len=24) "\tDog: _AnimalName[3:6],", + (string) (len=25) "\tFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=41) "\t_AnimalName[0:3]: Cat,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[0:3]): Cat,", + (string) (len=41) "\t_AnimalName[3:6]: Dog,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[3:6]): Dog,", + (string) (len=42) "\t_AnimalName[6:10]: Fish,", + (string) (len=42) "\tstrings.ToLower(_AnimalName[6:10]): Fish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=40) "func (x *Animal) Set(val string) error {", + (string) (len=27) "\tv, err := ParseAnimal(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=36) "func (x *Animal) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=32) "func (x *Animal) Type() string {", + (string) (len=16) "\treturn \"Animal\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=44) "\t// TestLower is a Cases of type Test_lower.", + (string) (len=23) "\tTestLower Cases = iota", + (string) (len=48) "\t// TestCapital is a Cases of type Test_capital.", + (string) (len=12) "\tTestCapital", + (string) (len=67) "\t// AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=22) "\tAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidCases = errors.New(\"not a valid Cases\")", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=41) "\tTestLower: _CasesName[0:10],", + (string) (len=42) "\tTestCapital: _CasesName[10:22],", + (string) (len=42) "\tAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=47) "\t_CasesName[0:10]: TestLower,", + (string) (len=47) "\tstrings.ToLower(_CasesName[0:10]): TestLower,", + (string) (len=49) "\t_CasesName[10:22]: TestCapital,", + (string) (len=49) "\tstrings.ToLower(_CasesName[10:22]): TestCapital,", + (string) (len=59) "\t_CasesName[22:43]: AnotherLowerCaseStart,", + (string) (len=59) "\tstrings.ToLower(_CasesName[22:43]): AnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Cases) Set(val string) error {", + (string) (len=26) "\tv, err := ParseCases(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Cases) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Cases) Type() string {", + (string) (len=15) "\treturn \"Cases\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=35) "\t// Black is a Color of type Black.", + (string) (len=19) "\tBlack Color = iota", + (string) (len=35) "\t// White is a Color of type White.", + (string) (len=6) "\tWhite", + (string) (len=31) "\t// Red is a Color of type Red.", + (string) (len=4) "\tRed", + (string) (len=35) "\t// Green is a Color of type Green.", + (string) (len=6) "\tGreen", + (string) (len=33) "\t// Blue is a Color of type Blue.", + (string) (len=23) "\tBlue Color = iota + 29", + (string) (len=33) "\t// Grey is a Color of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=37) "\t// Yellow is a Color of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidColor = errors.New(\"not a valid Color\")", + (string) "", + (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=25) "\tBlack: _ColorName[0:5],", + (string) (len=26) "\tWhite: _ColorName[5:10],", + (string) (len=27) "\tRed: _ColorName[10:13],", + (string) (len=27) "\tGreen: _ColorName[13:18],", + (string) (len=27) "\tBlue: _ColorName[18:22],", + (string) (len=27) "\tGrey: _ColorName[22:26],", + (string) (len=27) "\tYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=43) "\t_ColorName[0:5]: Black,", + (string) (len=43) "\tstrings.ToLower(_ColorName[0:5]): Black,", + (string) (len=43) "\t_ColorName[5:10]: White,", + (string) (len=43) "\tstrings.ToLower(_ColorName[5:10]): White,", + (string) (len=41) "\t_ColorName[10:13]: Red,", + (string) (len=41) "\tstrings.ToLower(_ColorName[10:13]): Red,", + (string) (len=43) "\t_ColorName[13:18]: Green,", + (string) (len=43) "\tstrings.ToLower(_ColorName[13:18]): Green,", + (string) (len=42) "\t_ColorName[18:22]: Blue,", + (string) (len=42) "\tstrings.ToLower(_ColorName[18:22]): Blue,", + (string) (len=42) "\t_ColorName[22:26]: Grey,", + (string) (len=42) "\tstrings.ToLower(_ColorName[22:26]): Grey,", + (string) (len=44) "\t_ColorName[26:32]: Yellow,", + (string) (len=44) "\tstrings.ToLower(_ColorName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Color) Set(val string) error {", + (string) (len=26) "\tv, err := ParseColor(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Color) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Color) Type() string {", + (string) (len=15) "\treturn \"Color\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=46) "\t// Black is a ColorWithComment of type Black.", + (string) (len=30) "\tBlack ColorWithComment = iota", + (string) (len=46) "\t// White is a ColorWithComment of type White.", + (string) (len=6) "\tWhite", + (string) (len=42) "\t// Red is a ColorWithComment of type Red.", + (string) (len=4) "\tRed", + (string) (len=46) "\t// Green is a ColorWithComment of type Green.", + (string) (len=6) "\tGreen", + (string) (len=44) "\t// Blue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=34) "\tBlue ColorWithComment = iota + 29", + (string) (len=44) "\t// Grey is a ColorWithComment of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=48) "\t// Yellow is a ColorWithComment of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=75) "var ErrInvalidColorWithComment = errors.New(\"not a valid ColorWithComment\")", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=36) "\tBlack: _ColorWithCommentName[0:5],", + (string) (len=37) "\tWhite: _ColorWithCommentName[5:10],", + (string) (len=38) "\tRed: _ColorWithCommentName[10:13],", + (string) (len=38) "\tGreen: _ColorWithCommentName[13:18],", + (string) (len=38) "\tBlue: _ColorWithCommentName[18:22],", + (string) (len=38) "\tGrey: _ColorWithCommentName[22:26],", + (string) (len=38) "\tYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=54) "\t_ColorWithCommentName[0:5]: Black,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[0:5]): Black,", + (string) (len=54) "\t_ColorWithCommentName[5:10]: White,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[5:10]): White,", + (string) (len=52) "\t_ColorWithCommentName[10:13]: Red,", + (string) (len=52) "\tstrings.ToLower(_ColorWithCommentName[10:13]): Red,", + (string) (len=54) "\t_ColorWithCommentName[13:18]: Green,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[13:18]): Green,", + (string) (len=53) "\t_ColorWithCommentName[18:22]: Blue,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[18:22]): Blue,", + (string) (len=53) "\t_ColorWithCommentName[22:26]: Grey,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[22:26]): Grey,", + (string) (len=55) "\t_ColorWithCommentName[26:32]: Yellow,", + (string) (len=55) "\tstrings.ToLower(_ColorWithCommentName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", + (string) (len=37) "\tv, err := ParseColorWithComment(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=42) "func (x *ColorWithComment) Type() string {", + (string) (len=26) "\treturn \"ColorWithComment\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment2 of type Black.", + (string) (len=31) "\tBlack ColorWithComment2 = iota", + (string) (len=47) "\t// White is a ColorWithComment2 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment2 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment2 of type Green.", + (string) (len=6) "\tGreen", + (string) (len=45) "\t// Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=35) "\tBlue ColorWithComment2 = iota + 29", + (string) (len=45) "\t// Grey is a ColorWithComment2 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment2 = errors.New(\"not a valid ColorWithComment2\")", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=37) "\tBlack: _ColorWithComment2Name[0:5],", + (string) (len=38) "\tWhite: _ColorWithComment2Name[5:10],", + (string) (len=39) "\tRed: _ColorWithComment2Name[10:13],", + (string) (len=39) "\tGreen: _ColorWithComment2Name[13:18],", + (string) (len=39) "\tBlue: _ColorWithComment2Name[18:22],", + (string) (len=39) "\tGrey: _ColorWithComment2Name[22:26],", + (string) (len=39) "\tYellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=55) "\t_ColorWithComment2Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment2Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment2Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment2Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment2Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment2Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment2Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment2(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment2) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment2\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment3 of type Black.", + (string) (len=31) "\tBlack ColorWithComment3 = iota", + (string) (len=47) "\t// White is a ColorWithComment3 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment3 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment3 = iota + 30", + (string) (len=45) "\t// Blue is a ColorWithComment3 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment3 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=10) "\tRedOrange", + (string) (len=65) "\t// RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=14) "\tRedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment3 = errors.New(\"not a valid ColorWithComment3\")", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=44) "\tBlack: _ColorWithComment3Name[0:5],", + (string) (len=45) "\tWhite: _ColorWithComment3Name[5:10],", + (string) (len=46) "\tRed: _ColorWithComment3Name[10:13],", + (string) (len=46) "\tGreen: _ColorWithComment3Name[13:18],", + (string) (len=46) "\tBlue: _ColorWithComment3Name[18:22],", + (string) (len=46) "\tGrey: _ColorWithComment3Name[22:26],", + (string) (len=46) "\tYellow: _ColorWithComment3Name[26:32],", + (string) (len=46) "\tBlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=46) "\tRedOrange: _ColorWithComment3Name[42:52],", + (string) (len=46) "\tRedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=55) "\t_ColorWithComment3Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment3Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment3Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment3Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment3Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment3Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment3Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment3Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment3Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): RedOrange,", + (string) (len=63) "\t_ColorWithComment3Name[52:67]: RedOrangeBlue,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment3(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment3) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment3\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=47) "\t// Black is a ColorWithComment4 of type Black.", + (string) (len=6) "\tBlack", + (string) (len=47) "\t// White is a ColorWithComment4 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment4 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment4 = iota + 29", + (string) (len=45) "\t// Blue is a ColorWithComment4 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment4 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=10) "\tRedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment4 = errors.New(\"not a valid ColorWithComment4\")", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=40) "\tBlack: _ColorWithComment4Name[0:5],", + (string) (len=41) "\tWhite: _ColorWithComment4Name[5:10],", + (string) (len=42) "\tRed: _ColorWithComment4Name[10:13],", + (string) (len=42) "\tGreen: _ColorWithComment4Name[13:18],", + (string) (len=42) "\tBlue: _ColorWithComment4Name[18:22],", + (string) (len=42) "\tGrey: _ColorWithComment4Name[22:26],", + (string) (len=42) "\tYellow: _ColorWithComment4Name[26:32],", + (string) (len=42) "\tBlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=42) "\tRedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=55) "\t_ColorWithComment4Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment4Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment4Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment4Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment4Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment4Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment4Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment4Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment4Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment4(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment4) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment4\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=43) "\t// Unknown is a Enum64bit of type Unknown.", + (string) (len=25) "\tUnknown Enum64bit = iota", + (string) (len=39) "\t// E2P15 is a Enum64bit of type E2P15.", + (string) (len=31) "\tE2P15 Enum64bit = iota + 32767", + (string) (len=39) "\t// E2P16 is a Enum64bit of type E2P16.", + (string) (len=31) "\tE2P16 Enum64bit = iota + 65534", + (string) (len=39) "\t// E2P17 is a Enum64bit of type E2P17.", + (string) (len=32) "\tE2P17 Enum64bit = iota + 131069", + (string) (len=39) "\t// E2P18 is a Enum64bit of type E2P18.", + (string) (len=32) "\tE2P18 Enum64bit = iota + 262140", + (string) (len=39) "\t// E2P19 is a Enum64bit of type E2P19.", + (string) (len=32) "\tE2P19 Enum64bit = iota + 524283", + (string) (len=39) "\t// E2P20 is a Enum64bit of type E2P20.", + (string) (len=33) "\tE2P20 Enum64bit = iota + 1048570", + (string) (len=39) "\t// E2P21 is a Enum64bit of type E2P21.", + (string) (len=33) "\tE2P21 Enum64bit = iota + 2097145", + (string) (len=39) "\t// E2P22 is a Enum64bit of type E2P22.", + (string) (len=34) "\tE2P22 Enum64bit = iota + 33554424", + (string) (len=39) "\t// E2P23 is a Enum64bit of type E2P23.", + (string) (len=34) "\tE2P23 Enum64bit = iota + 67108855", + (string) (len=39) "\t// E2P28 is a Enum64bit of type E2P28.", + (string) (len=35) "\tE2P28 Enum64bit = iota + 536870902", + (string) (len=39) "\t// E2P30 is a Enum64bit of type E2P30.", + (string) (len=36) "\tE2P30 Enum64bit = iota + 1073741813", + (string) (len=39) "\t// E2P31 is a Enum64bit of type E2P31.", + (string) (len=36) "\tE2P31 Enum64bit = iota + 2147483636", + (string) (len=39) "\t// E2P32 is a Enum64bit of type E2P32.", + (string) (len=36) "\tE2P32 Enum64bit = iota + 4294967283", + (string) (len=39) "\t// E2P33 is a Enum64bit of type E2P33.", + (string) (len=36) "\tE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=61) "var ErrInvalidEnum64bit = errors.New(\"not a valid Enum64bit\")", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=30) "\tUnknown: _Enum64bitName[0:7],", + (string) (len=31) "\tE2P15: _Enum64bitName[7:12],", + (string) (len=32) "\tE2P16: _Enum64bitName[12:17],", + (string) (len=32) "\tE2P17: _Enum64bitName[17:22],", + (string) (len=32) "\tE2P18: _Enum64bitName[22:27],", + (string) (len=32) "\tE2P19: _Enum64bitName[27:32],", + (string) (len=32) "\tE2P20: _Enum64bitName[32:37],", + (string) (len=32) "\tE2P21: _Enum64bitName[37:42],", + (string) (len=32) "\tE2P22: _Enum64bitName[42:47],", + (string) (len=32) "\tE2P23: _Enum64bitName[47:52],", + (string) (len=32) "\tE2P28: _Enum64bitName[52:57],", + (string) (len=32) "\tE2P30: _Enum64bitName[57:62],", + (string) (len=32) "\tE2P31: _Enum64bitName[62:67],", + (string) (len=32) "\tE2P32: _Enum64bitName[67:72],", + (string) (len=32) "\tE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=49) "\t_Enum64bitName[0:7]: Unknown,", + (string) (len=49) "\tstrings.ToLower(_Enum64bitName[0:7]): Unknown,", + (string) (len=47) "\t_Enum64bitName[7:12]: E2P15,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[7:12]): E2P15,", + (string) (len=47) "\t_Enum64bitName[12:17]: E2P16,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[12:17]): E2P16,", + (string) (len=47) "\t_Enum64bitName[17:22]: E2P17,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[17:22]): E2P17,", + (string) (len=47) "\t_Enum64bitName[22:27]: E2P18,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[22:27]): E2P18,", + (string) (len=47) "\t_Enum64bitName[27:32]: E2P19,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[27:32]): E2P19,", + (string) (len=47) "\t_Enum64bitName[32:37]: E2P20,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[32:37]): E2P20,", + (string) (len=47) "\t_Enum64bitName[37:42]: E2P21,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[37:42]): E2P21,", + (string) (len=47) "\t_Enum64bitName[42:47]: E2P22,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[42:47]): E2P22,", + (string) (len=47) "\t_Enum64bitName[47:52]: E2P23,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[47:52]): E2P23,", + (string) (len=47) "\t_Enum64bitName[52:57]: E2P28,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[52:57]): E2P28,", + (string) (len=47) "\t_Enum64bitName[57:62]: E2P30,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[57:62]): E2P30,", + (string) (len=47) "\t_Enum64bitName[62:67]: E2P31,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[62:67]): E2P31,", + (string) (len=47) "\t_Enum64bitName[67:72]: E2P32,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[67:72]): E2P32,", + (string) (len=47) "\t_Enum64bitName[72:77]: E2P33,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[72:77]): E2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=43) "func (x *Enum64bit) Set(val string) error {", + (string) (len=30) "\tv, err := ParseEnum64bit(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=39) "func (x *Enum64bit) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=35) "func (x *Enum64bit) Type() string {", + (string) (len=19) "\treturn \"Enum64bit\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=37) "\t// Toyota is a Model of type Toyota.", + (string) (len=20) "\tToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=35) "\t// Chevy is a Model of type Chevy.", + (string) (len=6) "\tChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=33) "\t// Ford is a Model of type Ford.", + (string) (len=5) "\tFord", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidModel = errors.New(\"not a valid Model\")", + (string) "", + (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=25) "\tToyota: _ModelName[0:6],", + (string) (len=26) "\tChevy: _ModelName[6:11],", + (string) (len=27) "\tFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=44) "\t_ModelName[0:6]: Toyota,", + (string) (len=44) "\tstrings.ToLower(_ModelName[0:6]): Toyota,", + (string) (len=43) "\t_ModelName[6:11]: Chevy,", + (string) (len=43) "\tstrings.ToLower(_ModelName[6:11]): Chevy,", + (string) (len=42) "\t_ModelName[11:15]: Ford,", + (string) (len=42) "\tstrings.ToLower(_ModelName[11:15]): Ford,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Model) Set(val string) error {", + (string) (len=26) "\tv, err := ParseModel(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Model) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Model) Type() string {", + (string) (len=15) "\treturn \"Model\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Продам is a NonASCII of type Продам.", + (string) (len=36) "\tПродам NonASCII = iota + 1114", + (string) (len=40) "\t// 車庫 is a NonASCII of type 車庫.", + (string) (len=29) "\t車庫 NonASCII = iota + 299", + (string) (len=44) "\t// Էժան is a NonASCII of type Էժան.", + (string) (len=30) "\tԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=59) "var ErrInvalidNonASCII = errors.New(\"not a valid NonASCII\")", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=35) "\tПродам: _NonASCIIName[0:12],", + (string) (len=34) "\t車庫: _NonASCIIName[12:18],", + (string) (len=34) "\tԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=53) "\t_NonASCIIName[0:12]: Продам,", + (string) (len=53) "\tstrings.ToLower(_NonASCIIName[0:12]): Продам,", + (string) (len=47) "\t_NonASCIIName[12:18]: 車庫,", + (string) (len=47) "\tstrings.ToLower(_NonASCIIName[12:18]): 車庫,", + (string) (len=49) "\t_NonASCIIName[18:26]: Էժան,", + (string) (len=49) "\tstrings.ToLower(_NonASCIIName[18:26]): Էժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=42) "func (x *NonASCII) Set(val string) error {", + (string) (len=29) "\tv, err := ParseNonASCII(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=38) "func (x *NonASCII) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=34) "func (x *NonASCII) Type() string {", + (string) (len=18) "\treturn \"NonASCII\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=51) "\t// TestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=29) "\tTestHyphen Sanitizing = iota", + (string) (len=54) "\t// XHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=13) "\tXHyphenStart", + (string) (len=62) "\t// XUnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=17) "\tXUnderscoreFirst", + (string) (len=55) "\t// X0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=14) "\tX0NumberFirst", + (string) (len=51) "\t// X123456789A is a Sanitizing of type 123456789A.", + (string) (len=12) "\tX123456789A", + (string) (len=52) "\t// X123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=12) "\tX123123Asdf", + (string) (len=56) "\t// EndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=13) "\tEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidSanitizing = errors.New(\"not a valid Sanitizing\")", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=41) "\tTestHyphen: _SanitizingName[0:11],", + (string) (len=42) "\tXHyphenStart: _SanitizingName[11:23],", + (string) (len=42) "\tXUnderscoreFirst: _SanitizingName[23:39],", + (string) (len=42) "\tX0NumberFirst: _SanitizingName[39:51],", + (string) (len=42) "\tX123456789A: _SanitizingName[51:61],", + (string) (len=42) "\tX123123Asdf: _SanitizingName[61:72],", + (string) (len=42) "\tEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=53) "\t_SanitizingName[0:11]: TestHyphen,", + (string) (len=53) "\tstrings.ToLower(_SanitizingName[0:11]): TestHyphen,", + (string) (len=55) "\t_SanitizingName[11:23]: XHyphenStart,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[11:23]): XHyphenStart,", + (string) (len=59) "\t_SanitizingName[23:39]: XUnderscoreFirst,", + (string) (len=59) "\tstrings.ToLower(_SanitizingName[23:39]): XUnderscoreFirst,", + (string) (len=56) "\t_SanitizingName[39:51]: X0NumberFirst,", + (string) (len=56) "\tstrings.ToLower(_SanitizingName[39:51]): X0NumberFirst,", + (string) (len=54) "\t_SanitizingName[51:61]: X123456789A,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[51:61]): X123456789A,", + (string) (len=54) "\t_SanitizingName[61:72]: X123123Asdf,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[61:72]): X123123Asdf,", + (string) (len=55) "\t_SanitizingName[72:86]: EndingHyphen,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[72:86]): EndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *Sanitizing) Set(val string) error {", + (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *Sanitizing) Type() string {", + (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Coke is a Soda of type Coke.", + (string) (len=17) "\tCoke Soda = iota", + (string) (len=34) "\t// Pepsi is a Soda of type Pepsi.", + (string) (len=6) "\tPepsi", + (string) (len=36) "\t// MtnDew is a Soda of type MtnDew.", + (string) (len=7) "\tMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=51) "var ErrInvalidSoda = errors.New(\"not a valid Soda\")", + (string) "", + (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=24) "\tCoke: _SodaName[0:4],", + (string) (len=24) "\tPepsi: _SodaName[4:9],", + (string) (len=25) "\tMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=40) "\t_SodaName[0:4]: Coke,", + (string) (len=40) "\tstrings.ToLower(_SodaName[0:4]): Coke,", + (string) (len=41) "\t_SodaName[4:9]: Pepsi,", + (string) (len=41) "\tstrings.ToLower(_SodaName[4:9]): Pepsi,", + (string) (len=42) "\t_SodaName[9:15]: MtnDew,", + (string) (len=42) "\tstrings.ToLower(_SodaName[9:15]): MtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=38) "func (x *Soda) Set(val string) error {", + (string) (len=25) "\tv, err := ParseSoda(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=34) "func (x *Soda) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=30) "func (x *Soda) Type() string {", + (string) (len=14) "\treturn \"Soda\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// StartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=38) "\tStartWithNum StartNotZero = iota + 23", + (string) (len=46) "\t// NextNum is a StartNotZero of type NextNum.", + (string) (len=8) "\tNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=67) "var ErrInvalidStartNotZero = errors.New(\"not a valid StartNotZero\")", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=39) "\tStartWithNum: _StartNotZeroName[0:12],", + (string) (len=40) "\tNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=57) "\t_StartNotZeroName[0:12]: StartWithNum,", + (string) (len=57) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartWithNum,", + (string) (len=52) "\t_StartNotZeroName[12:19]: NextNum,", + (string) (len=52) "\tstrings.ToLower(_StartNotZeroName[12:19]): NextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=46) "func (x *StartNotZero) Set(val string) error {", + (string) (len=33) "\tv, err := ParseStartNotZero(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=42) "func (x *StartNotZero) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=38) "func (x *StartNotZero) Type() string {", + (string) (len=22) "\treturn \"StartNotZero\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// Random is a StringEnum of type random.", + (string) (len=29) "\tRandom StringEnum = \"random\"", + (string) (len=42) "\t// Values is a StringEnum of type values.", + (string) (len=29) "\tValues StringEnum = \"values\"", + (string) (len=38) "\t// Here is a StringEnum of type here.", + (string) (len=25) "\tHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidStringEnum = errors.New(\"not a valid StringEnum\")", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=18) "\t\"random\": Random,", + (string) (len=18) "\t\"values\": Values,", + (string) (len=16) "\t\"here\": Here,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *StringEnum) Set(val string) error {", + (string) (len=31) "\tv, err := ParseStringEnum(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *StringEnum) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *StringEnum) Type() string {", + (string) (len=20) "\treturn \"StringEnum\"", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/TestCustomPrefixExampleFile b/generator/.snapshots/TestCustomPrefixExampleFile new file mode 100644 index 00000000..5921a187 --- /dev/null +++ b/generator/.snapshots/TestCustomPrefixExampleFile @@ -0,0 +1,4064 @@ +([]string) (len=4062) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=21) "\tjson \"encoding/json\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strconv\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=46) "\t// Custom_prefix_Cat is a Animal of type Cat.", + (string) (len=32) "\tCustom_prefix_Cat Animal = iota", + (string) (len=46) "\t// Custom_prefix_Dog is a Animal of type Dog.", + (string) (len=18) "\tCustom_prefix_Dog", + (string) (len=48) "\t// Custom_prefix_Fish is a Animal of type Fish.", + (string) (len=19) "\tCustom_prefix_Fish", + (string) (len=1) ")", + (string) "", + (string) (len=55) "var ErrInvalidAnimal = errors.New(\"not a valid Animal\")", + (string) "", + (string) (len=32) "const _AnimalName = \"CatDogFish\"", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=38) "\tCustom_prefix_Cat: _AnimalName[0:3],", + (string) (len=38) "\tCustom_prefix_Dog: _AnimalName[3:6],", + (string) (len=39) "\tCustom_prefix_Fish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=55) "\t_AnimalName[0:3]: Custom_prefix_Cat,", + (string) (len=55) "\tstrings.ToLower(_AnimalName[0:3]): Custom_prefix_Cat,", + (string) (len=55) "\t_AnimalName[3:6]: Custom_prefix_Dog,", + (string) (len=55) "\tstrings.ToLower(_AnimalName[3:6]): Custom_prefix_Dog,", + (string) (len=56) "\t_AnimalName[6:10]: Custom_prefix_Fish,", + (string) (len=56) "\tstrings.ToLower(_AnimalName[6:10]): Custom_prefix_Fish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=31) "func (x Animal) Ptr() *Animal {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=92) "var errAnimalNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=54) "func (x *Animal) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=16) "\t\t*x = Animal(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase string:", + (string) (len=26) "\t\t*x, err = ParseAnimal(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=30) "\t\t\t\t*x, err = Animal(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=34) "\t\t*x, err = ParseAnimal(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=30) "\t\t\t\t*x, err = Animal(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase Animal:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=14) "\tcase *Animal:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x, err = ParseAnimal(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=30) "\t\t\t\t*x, err = Animal(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=47) "func (x Animal) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=40) "func (x *Animal) Set(val string) error {", + (string) (len=27) "\tv, err := ParseAnimal(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=36) "func (x *Animal) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=32) "func (x *Animal) Type() string {", + (string) (len=16) "\treturn \"Animal\"", + (string) (len=1) "}", + (string) "", + (string) (len=24) "type NullAnimal struct {", + (string) (len=14) "\tAnimal Animal", + (string) (len=12) "\tValid bool", + (string) (len=12) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=52) "func NewNullAnimal(val interface{}) (x NullAnimal) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *NullAnimal) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=38) "\t\tx.Animal, x.Valid = Animal(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=27) "\terr = x.Animal.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x NullAnimal) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=28) "\treturn int64(x.Animal), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// MarshalJSON correctly serializes a NullAnimal to JSON.", + (string) (len=51) "func (n NullAnimal) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=31) "\t\treturn json.Marshal(n.Animal)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=63) "// UnmarshalJSON correctly deserializes a NullAnimal from JSON.", + (string) (len=52) "func (n *NullAnimal) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=27) "type NullAnimalStr struct {", + (string) (len=11) "\tNullAnimal", + (string) (len=1) "}", + (string) "", + (string) (len=58) "func NewNullAnimalStr(val interface{}) (x NullAnimalStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=54) "func (x NullAnimalStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=30) "\treturn x.Animal.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// MarshalJSON correctly serializes a NullAnimal to JSON.", + (string) (len=54) "func (n NullAnimalStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=31) "\t\treturn json.Marshal(n.Animal)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=63) "// UnmarshalJSON correctly deserializes a NullAnimal from JSON.", + (string) (len=55) "func (n *NullAnimalStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=59) "\t// Custom_prefix_Test_lower is a Cases of type Test_lower.", + (string) (len=38) "\tCustom_prefix_Test_lower Cases = iota", + (string) (len=63) "\t// Custom_prefix_Test_capital is a Cases of type Test_capital.", + (string) (len=27) "\tCustom_prefix_Test_capital", + (string) (len=81) "\t// Custom_prefix_AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=36) "\tCustom_prefix_AnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidCases = errors.New(\"not a valid Cases\")", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=55) "\tCustom_prefix_Test_lower: _CasesName[0:10],", + (string) (len=56) "\tCustom_prefix_Test_capital: _CasesName[10:22],", + (string) (len=56) "\tCustom_prefix_AnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=62) "\t_CasesName[0:10]: Custom_prefix_Test_lower,", + (string) (len=62) "\tstrings.ToLower(_CasesName[0:10]): Custom_prefix_Test_lower,", + (string) (len=64) "\t_CasesName[10:22]: Custom_prefix_Test_capital,", + (string) (len=64) "\tstrings.ToLower(_CasesName[10:22]): Custom_prefix_Test_capital,", + (string) (len=73) "\t_CasesName[22:43]: Custom_prefix_AnotherLowerCaseStart,", + (string) (len=73) "\tstrings.ToLower(_CasesName[22:43]): Custom_prefix_AnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=29) "func (x Cases) Ptr() *Cases {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errCasesNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Cases) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Cases(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseCases(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Cases(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseCases(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Cases(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=12) "\tcase Cases:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase *Cases:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseCases(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Cases(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Cases) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Cases) Set(val string) error {", + (string) (len=26) "\tv, err := ParseCases(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Cases) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Cases) Type() string {", + (string) (len=15) "\treturn \"Cases\"", + (string) (len=1) "}", + (string) "", + (string) (len=23) "type NullCases struct {", + (string) (len=12) "\tCases Cases", + (string) (len=11) "\tValid bool", + (string) (len=11) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=50) "func NewNullCases(val interface{}) (x NullCases) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *NullCases) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=36) "\t\tx.Cases, x.Valid = Cases(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=26) "\terr = x.Cases.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x NullCases) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=27) "\treturn int64(x.Cases), nil", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// MarshalJSON correctly serializes a NullCases to JSON.", + (string) (len=50) "func (n NullCases) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=30) "\t\treturn json.Marshal(n.Cases)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// UnmarshalJSON correctly deserializes a NullCases from JSON.", + (string) (len=51) "func (n *NullCases) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=26) "type NullCasesStr struct {", + (string) (len=10) "\tNullCases", + (string) (len=1) "}", + (string) "", + (string) (len=56) "func NewNullCasesStr(val interface{}) (x NullCasesStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x NullCasesStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=29) "\treturn x.Cases.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// MarshalJSON correctly serializes a NullCases to JSON.", + (string) (len=53) "func (n NullCasesStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=30) "\t\treturn json.Marshal(n.Cases)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// UnmarshalJSON correctly deserializes a NullCases from JSON.", + (string) (len=54) "func (n *NullCasesStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=49) "\t// Custom_prefix_Black is a Color of type Black.", + (string) (len=33) "\tCustom_prefix_Black Color = iota", + (string) (len=49) "\t// Custom_prefix_White is a Color of type White.", + (string) (len=20) "\tCustom_prefix_White", + (string) (len=45) "\t// Custom_prefix_Red is a Color of type Red.", + (string) (len=18) "\tCustom_prefix_Red", + (string) (len=49) "\t// Custom_prefix_Green is a Color of type Green.", + (string) (len=20) "\tCustom_prefix_Green", + (string) (len=47) "\t// Custom_prefix_Blue is a Color of type Blue.", + (string) (len=37) "\tCustom_prefix_Blue Color = iota + 29", + (string) (len=47) "\t// Custom_prefix_Grey is a Color of type Grey.", + (string) (len=19) "\tCustom_prefix_Grey", + (string) (len=51) "\t// Custom_prefix_Yellow is a Color of type Yellow.", + (string) (len=21) "\tCustom_prefix_Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidColor = errors.New(\"not a valid Color\")", + (string) "", + (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=39) "\tCustom_prefix_Black: _ColorName[0:5],", + (string) (len=40) "\tCustom_prefix_White: _ColorName[5:10],", + (string) (len=41) "\tCustom_prefix_Red: _ColorName[10:13],", + (string) (len=41) "\tCustom_prefix_Green: _ColorName[13:18],", + (string) (len=41) "\tCustom_prefix_Blue: _ColorName[18:22],", + (string) (len=41) "\tCustom_prefix_Grey: _ColorName[22:26],", + (string) (len=41) "\tCustom_prefix_Yellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=57) "\t_ColorName[0:5]: Custom_prefix_Black,", + (string) (len=57) "\tstrings.ToLower(_ColorName[0:5]): Custom_prefix_Black,", + (string) (len=57) "\t_ColorName[5:10]: Custom_prefix_White,", + (string) (len=57) "\tstrings.ToLower(_ColorName[5:10]): Custom_prefix_White,", + (string) (len=55) "\t_ColorName[10:13]: Custom_prefix_Red,", + (string) (len=55) "\tstrings.ToLower(_ColorName[10:13]): Custom_prefix_Red,", + (string) (len=57) "\t_ColorName[13:18]: Custom_prefix_Green,", + (string) (len=57) "\tstrings.ToLower(_ColorName[13:18]): Custom_prefix_Green,", + (string) (len=56) "\t_ColorName[18:22]: Custom_prefix_Blue,", + (string) (len=56) "\tstrings.ToLower(_ColorName[18:22]): Custom_prefix_Blue,", + (string) (len=56) "\t_ColorName[22:26]: Custom_prefix_Grey,", + (string) (len=56) "\tstrings.ToLower(_ColorName[22:26]): Custom_prefix_Grey,", + (string) (len=58) "\t_ColorName[26:32]: Custom_prefix_Yellow,", + (string) (len=58) "\tstrings.ToLower(_ColorName[26:32]): Custom_prefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=29) "func (x Color) Ptr() *Color {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errColorNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Color) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Color(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseColor(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Color(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseColor(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Color(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=12) "\tcase Color:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase *Color:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseColor(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Color(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Color) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Color) Set(val string) error {", + (string) (len=26) "\tv, err := ParseColor(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Color) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Color) Type() string {", + (string) (len=15) "\treturn \"Color\"", + (string) (len=1) "}", + (string) "", + (string) (len=23) "type NullColor struct {", + (string) (len=12) "\tColor Color", + (string) (len=11) "\tValid bool", + (string) (len=11) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=50) "func NewNullColor(val interface{}) (x NullColor) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *NullColor) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=36) "\t\tx.Color, x.Valid = Color(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=26) "\terr = x.Color.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x NullColor) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=27) "\treturn int64(x.Color), nil", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// MarshalJSON correctly serializes a NullColor to JSON.", + (string) (len=50) "func (n NullColor) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=30) "\t\treturn json.Marshal(n.Color)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// UnmarshalJSON correctly deserializes a NullColor from JSON.", + (string) (len=51) "func (n *NullColor) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=26) "type NullColorStr struct {", + (string) (len=10) "\tNullColor", + (string) (len=1) "}", + (string) "", + (string) (len=56) "func NewNullColorStr(val interface{}) (x NullColorStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x NullColorStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=29) "\treturn x.Color.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// MarshalJSON correctly serializes a NullColor to JSON.", + (string) (len=53) "func (n NullColorStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=30) "\t\treturn json.Marshal(n.Color)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// UnmarshalJSON correctly deserializes a NullColor from JSON.", + (string) (len=54) "func (n *NullColorStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=60) "\t// Custom_prefix_Black is a ColorWithComment of type Black.", + (string) (len=44) "\tCustom_prefix_Black ColorWithComment = iota", + (string) (len=60) "\t// Custom_prefix_White is a ColorWithComment of type White.", + (string) (len=20) "\tCustom_prefix_White", + (string) (len=56) "\t// Custom_prefix_Red is a ColorWithComment of type Red.", + (string) (len=18) "\tCustom_prefix_Red", + (string) (len=60) "\t// Custom_prefix_Green is a ColorWithComment of type Green.", + (string) (len=20) "\tCustom_prefix_Green", + (string) (len=58) "\t// Custom_prefix_Blue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=48) "\tCustom_prefix_Blue ColorWithComment = iota + 29", + (string) (len=58) "\t// Custom_prefix_Grey is a ColorWithComment of type Grey.", + (string) (len=19) "\tCustom_prefix_Grey", + (string) (len=62) "\t// Custom_prefix_Yellow is a ColorWithComment of type Yellow.", + (string) (len=21) "\tCustom_prefix_Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=75) "var ErrInvalidColorWithComment = errors.New(\"not a valid ColorWithComment\")", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=50) "\tCustom_prefix_Black: _ColorWithCommentName[0:5],", + (string) (len=51) "\tCustom_prefix_White: _ColorWithCommentName[5:10],", + (string) (len=52) "\tCustom_prefix_Red: _ColorWithCommentName[10:13],", + (string) (len=52) "\tCustom_prefix_Green: _ColorWithCommentName[13:18],", + (string) (len=52) "\tCustom_prefix_Blue: _ColorWithCommentName[18:22],", + (string) (len=52) "\tCustom_prefix_Grey: _ColorWithCommentName[22:26],", + (string) (len=52) "\tCustom_prefix_Yellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=68) "\t_ColorWithCommentName[0:5]: Custom_prefix_Black,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[0:5]): Custom_prefix_Black,", + (string) (len=68) "\t_ColorWithCommentName[5:10]: Custom_prefix_White,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[5:10]): Custom_prefix_White,", + (string) (len=66) "\t_ColorWithCommentName[10:13]: Custom_prefix_Red,", + (string) (len=66) "\tstrings.ToLower(_ColorWithCommentName[10:13]): Custom_prefix_Red,", + (string) (len=68) "\t_ColorWithCommentName[13:18]: Custom_prefix_Green,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[13:18]): Custom_prefix_Green,", + (string) (len=67) "\t_ColorWithCommentName[18:22]: Custom_prefix_Blue,", + (string) (len=67) "\tstrings.ToLower(_ColorWithCommentName[18:22]): Custom_prefix_Blue,", + (string) (len=67) "\t_ColorWithCommentName[22:26]: Custom_prefix_Grey,", + (string) (len=67) "\tstrings.ToLower(_ColorWithCommentName[22:26]): Custom_prefix_Grey,", + (string) (len=69) "\t_ColorWithCommentName[26:32]: Custom_prefix_Yellow,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[26:32]): Custom_prefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=51) "func (x ColorWithComment) Ptr() *ColorWithComment {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=102) "var errColorWithCommentNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=64) "func (x *ColorWithComment) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=26) "\t\t*x = ColorWithComment(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase string:", + (string) (len=36) "\t\t*x, err = ParseColorWithComment(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=40) "\t\t\t\t*x, err = ColorWithComment(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=44) "\t\t*x, err = ParseColorWithComment(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=40) "\t\t\t\t*x, err = ColorWithComment(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=23) "\tcase ColorWithComment:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=24) "\tcase *ColorWithComment:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=37) "\t\t*x, err = ParseColorWithComment(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=40) "\t\t\t\t*x, err = ColorWithComment(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x ColorWithComment) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", + (string) (len=37) "\tv, err := ParseColorWithComment(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=42) "func (x *ColorWithComment) Type() string {", + (string) (len=26) "\treturn \"ColorWithComment\"", + (string) (len=1) "}", + (string) "", + (string) (len=34) "type NullColorWithComment struct {", + (string) (len=34) "\tColorWithComment ColorWithComment", + (string) (len=22) "\tValid bool", + (string) (len=22) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=72) "func NewNullColorWithComment(val interface{}) (x NullColorWithComment) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=68) "func (x *NullColorWithComment) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=58) "\t\tx.ColorWithComment, x.Valid = ColorWithComment(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\terr = x.ColorWithComment.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=61) "func (x NullColorWithComment) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=38) "\treturn int64(x.ColorWithComment), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// MarshalJSON correctly serializes a NullColorWithComment to JSON.", + (string) (len=61) "func (n NullColorWithComment) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=41) "\t\treturn json.Marshal(n.ColorWithComment)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=73) "// UnmarshalJSON correctly deserializes a NullColorWithComment from JSON.", + (string) (len=62) "func (n *NullColorWithComment) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=37) "type NullColorWithCommentStr struct {", + (string) (len=21) "\tNullColorWithComment", + (string) (len=1) "}", + (string) "", + (string) (len=78) "func NewNullColorWithCommentStr(val interface{}) (x NullColorWithCommentStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=64) "func (x NullColorWithCommentStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=40) "\treturn x.ColorWithComment.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// MarshalJSON correctly serializes a NullColorWithComment to JSON.", + (string) (len=64) "func (n NullColorWithCommentStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=41) "\t\treturn json.Marshal(n.ColorWithComment)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=73) "// UnmarshalJSON correctly deserializes a NullColorWithComment from JSON.", + (string) (len=65) "func (n *NullColorWithCommentStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=61) "\t// Custom_prefix_Black is a ColorWithComment2 of type Black.", + (string) (len=45) "\tCustom_prefix_Black ColorWithComment2 = iota", + (string) (len=61) "\t// Custom_prefix_White is a ColorWithComment2 of type White.", + (string) (len=20) "\tCustom_prefix_White", + (string) (len=57) "\t// Custom_prefix_Red is a ColorWithComment2 of type Red.", + (string) (len=18) "\tCustom_prefix_Red", + (string) (len=61) "\t// Custom_prefix_Green is a ColorWithComment2 of type Green.", + (string) (len=20) "\tCustom_prefix_Green", + (string) (len=59) "\t// Custom_prefix_Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=49) "\tCustom_prefix_Blue ColorWithComment2 = iota + 29", + (string) (len=59) "\t// Custom_prefix_Grey is a ColorWithComment2 of type Grey.", + (string) (len=19) "\tCustom_prefix_Grey", + (string) (len=63) "\t// Custom_prefix_Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=21) "\tCustom_prefix_Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment2 = errors.New(\"not a valid ColorWithComment2\")", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=51) "\tCustom_prefix_Black: _ColorWithComment2Name[0:5],", + (string) (len=52) "\tCustom_prefix_White: _ColorWithComment2Name[5:10],", + (string) (len=53) "\tCustom_prefix_Red: _ColorWithComment2Name[10:13],", + (string) (len=53) "\tCustom_prefix_Green: _ColorWithComment2Name[13:18],", + (string) (len=53) "\tCustom_prefix_Blue: _ColorWithComment2Name[18:22],", + (string) (len=53) "\tCustom_prefix_Grey: _ColorWithComment2Name[22:26],", + (string) (len=53) "\tCustom_prefix_Yellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=69) "\t_ColorWithComment2Name[0:5]: Custom_prefix_Black,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): Custom_prefix_Black,", + (string) (len=69) "\t_ColorWithComment2Name[5:10]: Custom_prefix_White,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): Custom_prefix_White,", + (string) (len=67) "\t_ColorWithComment2Name[10:13]: Custom_prefix_Red,", + (string) (len=67) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): Custom_prefix_Red,", + (string) (len=69) "\t_ColorWithComment2Name[13:18]: Custom_prefix_Green,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): Custom_prefix_Green,", + (string) (len=68) "\t_ColorWithComment2Name[18:22]: Custom_prefix_Blue,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): Custom_prefix_Blue,", + (string) (len=68) "\t_ColorWithComment2Name[22:26]: Custom_prefix_Grey,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): Custom_prefix_Grey,", + (string) (len=70) "\t_ColorWithComment2Name[26:32]: Custom_prefix_Yellow,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): Custom_prefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "func (x ColorWithComment2) Ptr() *ColorWithComment2 {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment2NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment2) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment2(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment2(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment2(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment2(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment2(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=24) "\tcase ColorWithComment2:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=25) "\tcase *ColorWithComment2:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment2(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment2(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment2) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment2(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment2) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment2\"", + (string) (len=1) "}", + (string) "", + (string) (len=35) "type NullColorWithComment2 struct {", + (string) (len=36) "\tColorWithComment2 ColorWithComment2", + (string) (len=23) "\tValid bool", + (string) (len=23) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=74) "func NewNullColorWithComment2(val interface{}) (x NullColorWithComment2) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=69) "func (x *NullColorWithComment2) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=60) "\t\tx.ColorWithComment2, x.Valid = ColorWithComment2(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=38) "\terr = x.ColorWithComment2.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=62) "func (x NullColorWithComment2) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=39) "\treturn int64(x.ColorWithComment2), nil", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// MarshalJSON correctly serializes a NullColorWithComment2 to JSON.", + (string) (len=62) "func (n NullColorWithComment2) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=42) "\t\treturn json.Marshal(n.ColorWithComment2)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// UnmarshalJSON correctly deserializes a NullColorWithComment2 from JSON.", + (string) (len=63) "func (n *NullColorWithComment2) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=38) "type NullColorWithComment2Str struct {", + (string) (len=22) "\tNullColorWithComment2", + (string) (len=1) "}", + (string) "", + (string) (len=80) "func NewNullColorWithComment2Str(val interface{}) (x NullColorWithComment2Str) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=65) "func (x NullColorWithComment2Str) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=41) "\treturn x.ColorWithComment2.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// MarshalJSON correctly serializes a NullColorWithComment2 to JSON.", + (string) (len=65) "func (n NullColorWithComment2Str) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=42) "\t\treturn json.Marshal(n.ColorWithComment2)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// UnmarshalJSON correctly deserializes a NullColorWithComment2 from JSON.", + (string) (len=66) "func (n *NullColorWithComment2Str) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=61) "\t// Custom_prefix_Black is a ColorWithComment3 of type Black.", + (string) (len=45) "\tCustom_prefix_Black ColorWithComment3 = iota", + (string) (len=61) "\t// Custom_prefix_White is a ColorWithComment3 of type White.", + (string) (len=20) "\tCustom_prefix_White", + (string) (len=57) "\t// Custom_prefix_Red is a ColorWithComment3 of type Red.", + (string) (len=18) "\tCustom_prefix_Red", + (string) (len=61) "\t// Custom_prefix_Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=50) "\tCustom_prefix_Green ColorWithComment3 = iota + 30", + (string) (len=59) "\t// Custom_prefix_Blue is a ColorWithComment3 of type Blue.", + (string) (len=19) "\tCustom_prefix_Blue", + (string) (len=59) "\t// Custom_prefix_Grey is a ColorWithComment3 of type Grey.", + (string) (len=19) "\tCustom_prefix_Grey", + (string) (len=63) "\t// Custom_prefix_Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=21) "\tCustom_prefix_Yellow", + (string) (len=70) "\t// Custom_prefix_BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=24) "\tCustom_prefix_BlueGreen", + (string) (len=70) "\t// Custom_prefix_RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=24) "\tCustom_prefix_RedOrange", + (string) (len=79) "\t// Custom_prefix_RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=28) "\tCustom_prefix_RedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment3 = errors.New(\"not a valid ColorWithComment3\")", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=58) "\tCustom_prefix_Black: _ColorWithComment3Name[0:5],", + (string) (len=59) "\tCustom_prefix_White: _ColorWithComment3Name[5:10],", + (string) (len=60) "\tCustom_prefix_Red: _ColorWithComment3Name[10:13],", + (string) (len=60) "\tCustom_prefix_Green: _ColorWithComment3Name[13:18],", + (string) (len=60) "\tCustom_prefix_Blue: _ColorWithComment3Name[18:22],", + (string) (len=60) "\tCustom_prefix_Grey: _ColorWithComment3Name[22:26],", + (string) (len=60) "\tCustom_prefix_Yellow: _ColorWithComment3Name[26:32],", + (string) (len=60) "\tCustom_prefix_BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=60) "\tCustom_prefix_RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=60) "\tCustom_prefix_RedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=69) "\t_ColorWithComment3Name[0:5]: Custom_prefix_Black,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): Custom_prefix_Black,", + (string) (len=69) "\t_ColorWithComment3Name[5:10]: Custom_prefix_White,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): Custom_prefix_White,", + (string) (len=67) "\t_ColorWithComment3Name[10:13]: Custom_prefix_Red,", + (string) (len=67) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): Custom_prefix_Red,", + (string) (len=69) "\t_ColorWithComment3Name[13:18]: Custom_prefix_Green,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): Custom_prefix_Green,", + (string) (len=68) "\t_ColorWithComment3Name[18:22]: Custom_prefix_Blue,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): Custom_prefix_Blue,", + (string) (len=68) "\t_ColorWithComment3Name[22:26]: Custom_prefix_Grey,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): Custom_prefix_Grey,", + (string) (len=70) "\t_ColorWithComment3Name[26:32]: Custom_prefix_Yellow,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): Custom_prefix_Yellow,", + (string) (len=73) "\t_ColorWithComment3Name[32:42]: Custom_prefix_BlueGreen,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): Custom_prefix_BlueGreen,", + (string) (len=73) "\t_ColorWithComment3Name[42:52]: Custom_prefix_RedOrange,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): Custom_prefix_RedOrange,", + (string) (len=77) "\t_ColorWithComment3Name[52:67]: Custom_prefix_RedOrangeBlue,", + (string) (len=77) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): Custom_prefix_RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "func (x ColorWithComment3) Ptr() *ColorWithComment3 {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment3NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment3) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment3(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment3(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment3(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment3(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment3(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=24) "\tcase ColorWithComment3:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=25) "\tcase *ColorWithComment3:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment3(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment3(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment3) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment3(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment3) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment3\"", + (string) (len=1) "}", + (string) "", + (string) (len=35) "type NullColorWithComment3 struct {", + (string) (len=36) "\tColorWithComment3 ColorWithComment3", + (string) (len=23) "\tValid bool", + (string) (len=23) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=74) "func NewNullColorWithComment3(val interface{}) (x NullColorWithComment3) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=69) "func (x *NullColorWithComment3) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=60) "\t\tx.ColorWithComment3, x.Valid = ColorWithComment3(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=38) "\terr = x.ColorWithComment3.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=62) "func (x NullColorWithComment3) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=39) "\treturn int64(x.ColorWithComment3), nil", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// MarshalJSON correctly serializes a NullColorWithComment3 to JSON.", + (string) (len=62) "func (n NullColorWithComment3) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=42) "\t\treturn json.Marshal(n.ColorWithComment3)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// UnmarshalJSON correctly deserializes a NullColorWithComment3 from JSON.", + (string) (len=63) "func (n *NullColorWithComment3) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=38) "type NullColorWithComment3Str struct {", + (string) (len=22) "\tNullColorWithComment3", + (string) (len=1) "}", + (string) "", + (string) (len=80) "func NewNullColorWithComment3Str(val interface{}) (x NullColorWithComment3Str) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=65) "func (x NullColorWithComment3Str) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=41) "\treturn x.ColorWithComment3.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// MarshalJSON correctly serializes a NullColorWithComment3 to JSON.", + (string) (len=65) "func (n NullColorWithComment3Str) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=42) "\t\treturn json.Marshal(n.ColorWithComment3)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// UnmarshalJSON correctly deserializes a NullColorWithComment3 from JSON.", + (string) (len=66) "func (n *NullColorWithComment3Str) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=61) "\t// Custom_prefix_Black is a ColorWithComment4 of type Black.", + (string) (len=20) "\tCustom_prefix_Black", + (string) (len=61) "\t// Custom_prefix_White is a ColorWithComment4 of type White.", + (string) (len=20) "\tCustom_prefix_White", + (string) (len=57) "\t// Custom_prefix_Red is a ColorWithComment4 of type Red.", + (string) (len=18) "\tCustom_prefix_Red", + (string) (len=61) "\t// Custom_prefix_Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=50) "\tCustom_prefix_Green ColorWithComment4 = iota + 29", + (string) (len=59) "\t// Custom_prefix_Blue is a ColorWithComment4 of type Blue.", + (string) (len=19) "\tCustom_prefix_Blue", + (string) (len=59) "\t// Custom_prefix_Grey is a ColorWithComment4 of type Grey.", + (string) (len=19) "\tCustom_prefix_Grey", + (string) (len=63) "\t// Custom_prefix_Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=21) "\tCustom_prefix_Yellow", + (string) (len=70) "\t// Custom_prefix_BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=24) "\tCustom_prefix_BlueGreen", + (string) (len=70) "\t// Custom_prefix_RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=24) "\tCustom_prefix_RedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment4 = errors.New(\"not a valid ColorWithComment4\")", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=54) "\tCustom_prefix_Black: _ColorWithComment4Name[0:5],", + (string) (len=55) "\tCustom_prefix_White: _ColorWithComment4Name[5:10],", + (string) (len=56) "\tCustom_prefix_Red: _ColorWithComment4Name[10:13],", + (string) (len=56) "\tCustom_prefix_Green: _ColorWithComment4Name[13:18],", + (string) (len=56) "\tCustom_prefix_Blue: _ColorWithComment4Name[18:22],", + (string) (len=56) "\tCustom_prefix_Grey: _ColorWithComment4Name[22:26],", + (string) (len=56) "\tCustom_prefix_Yellow: _ColorWithComment4Name[26:32],", + (string) (len=56) "\tCustom_prefix_BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=56) "\tCustom_prefix_RedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=69) "\t_ColorWithComment4Name[0:5]: Custom_prefix_Black,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): Custom_prefix_Black,", + (string) (len=69) "\t_ColorWithComment4Name[5:10]: Custom_prefix_White,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): Custom_prefix_White,", + (string) (len=67) "\t_ColorWithComment4Name[10:13]: Custom_prefix_Red,", + (string) (len=67) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): Custom_prefix_Red,", + (string) (len=69) "\t_ColorWithComment4Name[13:18]: Custom_prefix_Green,", + (string) (len=69) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): Custom_prefix_Green,", + (string) (len=68) "\t_ColorWithComment4Name[18:22]: Custom_prefix_Blue,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): Custom_prefix_Blue,", + (string) (len=68) "\t_ColorWithComment4Name[22:26]: Custom_prefix_Grey,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): Custom_prefix_Grey,", + (string) (len=70) "\t_ColorWithComment4Name[26:32]: Custom_prefix_Yellow,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): Custom_prefix_Yellow,", + (string) (len=73) "\t_ColorWithComment4Name[32:42]: Custom_prefix_BlueGreen,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): Custom_prefix_BlueGreen,", + (string) (len=73) "\t_ColorWithComment4Name[42:52]: Custom_prefix_RedOrange,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): Custom_prefix_RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "func (x ColorWithComment4) Ptr() *ColorWithComment4 {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment4NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment4) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment4(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment4(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment4(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment4(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment4(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=24) "\tcase ColorWithComment4:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=25) "\tcase *ColorWithComment4:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment4(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=41) "\t\t\t\t*x, err = ColorWithComment4(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment4) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment4(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment4) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment4\"", + (string) (len=1) "}", + (string) "", + (string) (len=35) "type NullColorWithComment4 struct {", + (string) (len=36) "\tColorWithComment4 ColorWithComment4", + (string) (len=23) "\tValid bool", + (string) (len=23) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=74) "func NewNullColorWithComment4(val interface{}) (x NullColorWithComment4) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=69) "func (x *NullColorWithComment4) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=60) "\t\tx.ColorWithComment4, x.Valid = ColorWithComment4(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=38) "\terr = x.ColorWithComment4.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=62) "func (x NullColorWithComment4) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=39) "\treturn int64(x.ColorWithComment4), nil", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// MarshalJSON correctly serializes a NullColorWithComment4 to JSON.", + (string) (len=62) "func (n NullColorWithComment4) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=42) "\t\treturn json.Marshal(n.ColorWithComment4)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// UnmarshalJSON correctly deserializes a NullColorWithComment4 from JSON.", + (string) (len=63) "func (n *NullColorWithComment4) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=38) "type NullColorWithComment4Str struct {", + (string) (len=22) "\tNullColorWithComment4", + (string) (len=1) "}", + (string) "", + (string) (len=80) "func NewNullColorWithComment4Str(val interface{}) (x NullColorWithComment4Str) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=65) "func (x NullColorWithComment4Str) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=41) "\treturn x.ColorWithComment4.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// MarshalJSON correctly serializes a NullColorWithComment4 to JSON.", + (string) (len=65) "func (n NullColorWithComment4Str) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=42) "\t\treturn json.Marshal(n.ColorWithComment4)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// UnmarshalJSON correctly deserializes a NullColorWithComment4 from JSON.", + (string) (len=66) "func (n *NullColorWithComment4Str) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=57) "\t// Custom_prefix_Unknown is a Enum64bit of type Unknown.", + (string) (len=39) "\tCustom_prefix_Unknown Enum64bit = iota", + (string) (len=53) "\t// Custom_prefix_E2P15 is a Enum64bit of type E2P15.", + (string) (len=45) "\tCustom_prefix_E2P15 Enum64bit = iota + 32767", + (string) (len=53) "\t// Custom_prefix_E2P16 is a Enum64bit of type E2P16.", + (string) (len=45) "\tCustom_prefix_E2P16 Enum64bit = iota + 65534", + (string) (len=53) "\t// Custom_prefix_E2P17 is a Enum64bit of type E2P17.", + (string) (len=46) "\tCustom_prefix_E2P17 Enum64bit = iota + 131069", + (string) (len=53) "\t// Custom_prefix_E2P18 is a Enum64bit of type E2P18.", + (string) (len=46) "\tCustom_prefix_E2P18 Enum64bit = iota + 262140", + (string) (len=53) "\t// Custom_prefix_E2P19 is a Enum64bit of type E2P19.", + (string) (len=46) "\tCustom_prefix_E2P19 Enum64bit = iota + 524283", + (string) (len=53) "\t// Custom_prefix_E2P20 is a Enum64bit of type E2P20.", + (string) (len=47) "\tCustom_prefix_E2P20 Enum64bit = iota + 1048570", + (string) (len=53) "\t// Custom_prefix_E2P21 is a Enum64bit of type E2P21.", + (string) (len=47) "\tCustom_prefix_E2P21 Enum64bit = iota + 2097145", + (string) (len=53) "\t// Custom_prefix_E2P22 is a Enum64bit of type E2P22.", + (string) (len=48) "\tCustom_prefix_E2P22 Enum64bit = iota + 33554424", + (string) (len=53) "\t// Custom_prefix_E2P23 is a Enum64bit of type E2P23.", + (string) (len=48) "\tCustom_prefix_E2P23 Enum64bit = iota + 67108855", + (string) (len=53) "\t// Custom_prefix_E2P28 is a Enum64bit of type E2P28.", + (string) (len=49) "\tCustom_prefix_E2P28 Enum64bit = iota + 536870902", + (string) (len=53) "\t// Custom_prefix_E2P30 is a Enum64bit of type E2P30.", + (string) (len=50) "\tCustom_prefix_E2P30 Enum64bit = iota + 1073741813", + (string) (len=53) "\t// Custom_prefix_E2P31 is a Enum64bit of type E2P31.", + (string) (len=50) "\tCustom_prefix_E2P31 Enum64bit = iota + 2147483636", + (string) (len=53) "\t// Custom_prefix_E2P32 is a Enum64bit of type E2P32.", + (string) (len=50) "\tCustom_prefix_E2P32 Enum64bit = iota + 4294967283", + (string) (len=53) "\t// Custom_prefix_E2P33 is a Enum64bit of type E2P33.", + (string) (len=50) "\tCustom_prefix_E2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=61) "var ErrInvalidEnum64bit = errors.New(\"not a valid Enum64bit\")", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=44) "\tCustom_prefix_Unknown: _Enum64bitName[0:7],", + (string) (len=45) "\tCustom_prefix_E2P15: _Enum64bitName[7:12],", + (string) (len=46) "\tCustom_prefix_E2P16: _Enum64bitName[12:17],", + (string) (len=46) "\tCustom_prefix_E2P17: _Enum64bitName[17:22],", + (string) (len=46) "\tCustom_prefix_E2P18: _Enum64bitName[22:27],", + (string) (len=46) "\tCustom_prefix_E2P19: _Enum64bitName[27:32],", + (string) (len=46) "\tCustom_prefix_E2P20: _Enum64bitName[32:37],", + (string) (len=46) "\tCustom_prefix_E2P21: _Enum64bitName[37:42],", + (string) (len=46) "\tCustom_prefix_E2P22: _Enum64bitName[42:47],", + (string) (len=46) "\tCustom_prefix_E2P23: _Enum64bitName[47:52],", + (string) (len=46) "\tCustom_prefix_E2P28: _Enum64bitName[52:57],", + (string) (len=46) "\tCustom_prefix_E2P30: _Enum64bitName[57:62],", + (string) (len=46) "\tCustom_prefix_E2P31: _Enum64bitName[62:67],", + (string) (len=46) "\tCustom_prefix_E2P32: _Enum64bitName[67:72],", + (string) (len=46) "\tCustom_prefix_E2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=63) "\t_Enum64bitName[0:7]: Custom_prefix_Unknown,", + (string) (len=63) "\tstrings.ToLower(_Enum64bitName[0:7]): Custom_prefix_Unknown,", + (string) (len=61) "\t_Enum64bitName[7:12]: Custom_prefix_E2P15,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[7:12]): Custom_prefix_E2P15,", + (string) (len=61) "\t_Enum64bitName[12:17]: Custom_prefix_E2P16,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[12:17]): Custom_prefix_E2P16,", + (string) (len=61) "\t_Enum64bitName[17:22]: Custom_prefix_E2P17,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[17:22]): Custom_prefix_E2P17,", + (string) (len=61) "\t_Enum64bitName[22:27]: Custom_prefix_E2P18,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[22:27]): Custom_prefix_E2P18,", + (string) (len=61) "\t_Enum64bitName[27:32]: Custom_prefix_E2P19,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[27:32]): Custom_prefix_E2P19,", + (string) (len=61) "\t_Enum64bitName[32:37]: Custom_prefix_E2P20,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[32:37]): Custom_prefix_E2P20,", + (string) (len=61) "\t_Enum64bitName[37:42]: Custom_prefix_E2P21,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[37:42]): Custom_prefix_E2P21,", + (string) (len=61) "\t_Enum64bitName[42:47]: Custom_prefix_E2P22,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[42:47]): Custom_prefix_E2P22,", + (string) (len=61) "\t_Enum64bitName[47:52]: Custom_prefix_E2P23,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[47:52]): Custom_prefix_E2P23,", + (string) (len=61) "\t_Enum64bitName[52:57]: Custom_prefix_E2P28,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[52:57]): Custom_prefix_E2P28,", + (string) (len=61) "\t_Enum64bitName[57:62]: Custom_prefix_E2P30,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[57:62]): Custom_prefix_E2P30,", + (string) (len=61) "\t_Enum64bitName[62:67]: Custom_prefix_E2P31,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[62:67]): Custom_prefix_E2P31,", + (string) (len=61) "\t_Enum64bitName[67:72]: Custom_prefix_E2P32,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[67:72]): Custom_prefix_E2P32,", + (string) (len=61) "\t_Enum64bitName[72:77]: Custom_prefix_E2P33,", + (string) (len=61) "\tstrings.ToLower(_Enum64bitName[72:77]): Custom_prefix_E2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=37) "func (x Enum64bit) Ptr() *Enum64bit {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=95) "var errEnum64bitNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *Enum64bit) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=19) "\t\t*x = Enum64bit(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase string:", + (string) (len=29) "\t\t*x, err = ParseEnum64bit(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=33) "\t\t\t\t*x, err = Enum64bit(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=37) "\t\t*x, err = ParseEnum64bit(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=33) "\t\t\t\t*x, err = Enum64bit(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=16) "\tcase Enum64bit:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=17) "\tcase *Enum64bit:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=30) "\t\t*x, err = ParseEnum64bit(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=33) "\t\t\t\t*x, err = Enum64bit(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x Enum64bit) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=43) "func (x *Enum64bit) Set(val string) error {", + (string) (len=30) "\tv, err := ParseEnum64bit(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=39) "func (x *Enum64bit) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=35) "func (x *Enum64bit) Type() string {", + (string) (len=19) "\treturn \"Enum64bit\"", + (string) (len=1) "}", + (string) "", + (string) (len=27) "type NullEnum64bit struct {", + (string) (len=20) "\tEnum64bit Enum64bit", + (string) (len=15) "\tValid bool", + (string) (len=15) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=58) "func NewNullEnum64bit(val interface{}) (x NullEnum64bit) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=61) "func (x *NullEnum64bit) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=44) "\t\tx.Enum64bit, x.Valid = Enum64bit(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=30) "\terr = x.Enum64bit.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=54) "func (x NullEnum64bit) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=31) "\treturn int64(x.Enum64bit), nil", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// MarshalJSON correctly serializes a NullEnum64bit to JSON.", + (string) (len=54) "func (n NullEnum64bit) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=34) "\t\treturn json.Marshal(n.Enum64bit)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// UnmarshalJSON correctly deserializes a NullEnum64bit from JSON.", + (string) (len=55) "func (n *NullEnum64bit) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=30) "type NullEnum64bitStr struct {", + (string) (len=14) "\tNullEnum64bit", + (string) (len=1) "}", + (string) "", + (string) (len=64) "func NewNullEnum64bitStr(val interface{}) (x NullEnum64bitStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x NullEnum64bitStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=33) "\treturn x.Enum64bit.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// MarshalJSON correctly serializes a NullEnum64bit to JSON.", + (string) (len=57) "func (n NullEnum64bitStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=34) "\t\treturn json.Marshal(n.Enum64bit)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// UnmarshalJSON correctly deserializes a NullEnum64bit from JSON.", + (string) (len=58) "func (n *NullEnum64bitStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=51) "\t// Custom_prefix_Toyota is a Model of type Toyota.", + (string) (len=34) "\tCustom_prefix_Toyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=49) "\t// Custom_prefix_Chevy is a Model of type Chevy.", + (string) (len=20) "\tCustom_prefix_Chevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=47) "\t// Custom_prefix_Ford is a Model of type Ford.", + (string) (len=19) "\tCustom_prefix_Ford", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidModel = errors.New(\"not a valid Model\")", + (string) "", + (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=39) "\tCustom_prefix_Toyota: _ModelName[0:6],", + (string) (len=40) "\tCustom_prefix_Chevy: _ModelName[6:11],", + (string) (len=41) "\tCustom_prefix_Ford: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=58) "\t_ModelName[0:6]: Custom_prefix_Toyota,", + (string) (len=58) "\tstrings.ToLower(_ModelName[0:6]): Custom_prefix_Toyota,", + (string) (len=57) "\t_ModelName[6:11]: Custom_prefix_Chevy,", + (string) (len=57) "\tstrings.ToLower(_ModelName[6:11]): Custom_prefix_Chevy,", + (string) (len=56) "\t_ModelName[11:15]: Custom_prefix_Ford,", + (string) (len=56) "\tstrings.ToLower(_ModelName[11:15]): Custom_prefix_Ford,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=29) "func (x Model) Ptr() *Model {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errModelNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Model) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Model(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseModel(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Model(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseModel(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Model(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=12) "\tcase Model:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase *Model:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseModel(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=29) "\t\t\t\t*x, err = Model(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Model) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Model) Set(val string) error {", + (string) (len=26) "\tv, err := ParseModel(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Model) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Model) Type() string {", + (string) (len=15) "\treturn \"Model\"", + (string) (len=1) "}", + (string) "", + (string) (len=23) "type NullModel struct {", + (string) (len=12) "\tModel Model", + (string) (len=11) "\tValid bool", + (string) (len=11) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=50) "func NewNullModel(val interface{}) (x NullModel) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *NullModel) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=36) "\t\tx.Model, x.Valid = Model(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=26) "\terr = x.Model.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x NullModel) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=27) "\treturn int64(x.Model), nil", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// MarshalJSON correctly serializes a NullModel to JSON.", + (string) (len=50) "func (n NullModel) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=30) "\t\treturn json.Marshal(n.Model)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// UnmarshalJSON correctly deserializes a NullModel from JSON.", + (string) (len=51) "func (n *NullModel) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=26) "type NullModelStr struct {", + (string) (len=10) "\tNullModel", + (string) (len=1) "}", + (string) "", + (string) (len=56) "func NewNullModelStr(val interface{}) (x NullModelStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x NullModelStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=29) "\treturn x.Model.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// MarshalJSON correctly serializes a NullModel to JSON.", + (string) (len=53) "func (n NullModelStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=30) "\t\treturn json.Marshal(n.Model)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// UnmarshalJSON correctly deserializes a NullModel from JSON.", + (string) (len=54) "func (n *NullModelStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=66) "\t// Custom_prefix_Продам is a NonASCII of type Продам.", + (string) (len=50) "\tCustom_prefix_Продам NonASCII = iota + 1114", + (string) (len=54) "\t// Custom_prefix_車庫 is a NonASCII of type 車庫.", + (string) (len=43) "\tCustom_prefix_車庫 NonASCII = iota + 299", + (string) (len=58) "\t// Custom_prefix_Էժան is a NonASCII of type Էժան.", + (string) (len=44) "\tCustom_prefix_Էժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=59) "var ErrInvalidNonASCII = errors.New(\"not a valid NonASCII\")", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=49) "\tCustom_prefix_Продам: _NonASCIIName[0:12],", + (string) (len=48) "\tCustom_prefix_車庫: _NonASCIIName[12:18],", + (string) (len=48) "\tCustom_prefix_Էժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=67) "\t_NonASCIIName[0:12]: Custom_prefix_Продам,", + (string) (len=67) "\tstrings.ToLower(_NonASCIIName[0:12]): Custom_prefix_Продам,", + (string) (len=61) "\t_NonASCIIName[12:18]: Custom_prefix_車庫,", + (string) (len=61) "\tstrings.ToLower(_NonASCIIName[12:18]): Custom_prefix_車庫,", + (string) (len=63) "\t_NonASCIIName[18:26]: Custom_prefix_Էժան,", + (string) (len=63) "\tstrings.ToLower(_NonASCIIName[18:26]): Custom_prefix_Էժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=35) "func (x NonASCII) Ptr() *NonASCII {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=94) "var errNonASCIINilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=56) "func (x *NonASCII) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=18) "\t\t*x = NonASCII(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase string:", + (string) (len=28) "\t\t*x, err = ParseNonASCII(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=32) "\t\t\t\t*x, err = NonASCII(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=36) "\t\t*x, err = ParseNonASCII(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=32) "\t\t\t\t*x, err = NonASCII(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=15) "\tcase NonASCII:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=16) "\tcase *NonASCII:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=29) "\t\t*x, err = ParseNonASCII(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=32) "\t\t\t\t*x, err = NonASCII(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=49) "func (x NonASCII) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=42) "func (x *NonASCII) Set(val string) error {", + (string) (len=29) "\tv, err := ParseNonASCII(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=38) "func (x *NonASCII) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=34) "func (x *NonASCII) Type() string {", + (string) (len=18) "\treturn \"NonASCII\"", + (string) (len=1) "}", + (string) "", + (string) (len=26) "type NullNonASCII struct {", + (string) (len=18) "\tNonASCII NonASCII", + (string) (len=14) "\tValid bool", + (string) (len=14) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=56) "func NewNullNonASCII(val interface{}) (x NullNonASCII) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=60) "func (x *NullNonASCII) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=42) "\t\tx.NonASCII, x.Valid = NonASCII(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=29) "\terr = x.NonASCII.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x NullNonASCII) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=30) "\treturn int64(x.NonASCII), nil", + (string) (len=1) "}", + (string) "", + (string) (len=59) "// MarshalJSON correctly serializes a NullNonASCII to JSON.", + (string) (len=53) "func (n NullNonASCII) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=33) "\t\treturn json.Marshal(n.NonASCII)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=65) "// UnmarshalJSON correctly deserializes a NullNonASCII from JSON.", + (string) (len=54) "func (n *NullNonASCII) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=29) "type NullNonASCIIStr struct {", + (string) (len=13) "\tNullNonASCII", + (string) (len=1) "}", + (string) "", + (string) (len=62) "func NewNullNonASCIIStr(val interface{}) (x NullNonASCIIStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=56) "func (x NullNonASCIIStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=32) "\treturn x.NonASCII.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=59) "// MarshalJSON correctly serializes a NullNonASCII to JSON.", + (string) (len=56) "func (n NullNonASCIIStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=33) "\t\treturn json.Marshal(n.NonASCII)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=65) "// UnmarshalJSON correctly deserializes a NullNonASCII from JSON.", + (string) (len=57) "func (n *NullNonASCIIStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=65) "\t// Custom_prefix_TestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=43) "\tCustom_prefix_TestHyphen Sanitizing = iota", + (string) (len=67) "\t// Custom_prefix_HyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=26) "\tCustom_prefix_HyphenStart", + (string) (len=76) "\t// Custom_prefix__UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=31) "\tCustom_prefix__UnderscoreFirst", + (string) (len=68) "\t// Custom_prefix_0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=27) "\tCustom_prefix_0NumberFirst", + (string) (len=64) "\t// Custom_prefix_123456789A is a Sanitizing of type 123456789A.", + (string) (len=25) "\tCustom_prefix_123456789A", + (string) (len=65) "\t// Custom_prefix_123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=25) "\tCustom_prefix_123123Asdf", + (string) (len=70) "\t// Custom_prefix_EndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=27) "\tCustom_prefix_EndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidSanitizing = errors.New(\"not a valid Sanitizing\")", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=55) "\tCustom_prefix_TestHyphen: _SanitizingName[0:11],", + (string) (len=56) "\tCustom_prefix_HyphenStart: _SanitizingName[11:23],", + (string) (len=56) "\tCustom_prefix__UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=56) "\tCustom_prefix_0NumberFirst: _SanitizingName[39:51],", + (string) (len=56) "\tCustom_prefix_123456789A: _SanitizingName[51:61],", + (string) (len=56) "\tCustom_prefix_123123Asdf: _SanitizingName[61:72],", + (string) (len=56) "\tCustom_prefix_EndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=67) "\t_SanitizingName[0:11]: Custom_prefix_TestHyphen,", + (string) (len=67) "\tstrings.ToLower(_SanitizingName[0:11]): Custom_prefix_TestHyphen,", + (string) (len=68) "\t_SanitizingName[11:23]: Custom_prefix_HyphenStart,", + (string) (len=68) "\tstrings.ToLower(_SanitizingName[11:23]): Custom_prefix_HyphenStart,", + (string) (len=73) "\t_SanitizingName[23:39]: Custom_prefix__UnderscoreFirst,", + (string) (len=73) "\tstrings.ToLower(_SanitizingName[23:39]): Custom_prefix__UnderscoreFirst,", + (string) (len=69) "\t_SanitizingName[39:51]: Custom_prefix_0NumberFirst,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[39:51]): Custom_prefix_0NumberFirst,", + (string) (len=67) "\t_SanitizingName[51:61]: Custom_prefix_123456789A,", + (string) (len=67) "\tstrings.ToLower(_SanitizingName[51:61]): Custom_prefix_123456789A,", + (string) (len=67) "\t_SanitizingName[61:72]: Custom_prefix_123123Asdf,", + (string) (len=67) "\tstrings.ToLower(_SanitizingName[61:72]): Custom_prefix_123123Asdf,", + (string) (len=69) "\t_SanitizingName[72:86]: Custom_prefix_EndingHyphen,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[72:86]): Custom_prefix_EndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=39) "func (x Sanitizing) Ptr() *Sanitizing {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errSanitizingNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = Sanitizing(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseSanitizing(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseSanitizing(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=17) "\tcase Sanitizing:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\tcase *Sanitizing:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=34) "\t\t\t\t*x, err = Sanitizing(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x Sanitizing) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *Sanitizing) Set(val string) error {", + (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *Sanitizing) Type() string {", + (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=1) "}", + (string) "", + (string) (len=28) "type NullSanitizing struct {", + (string) (len=22) "\tSanitizing Sanitizing", + (string) (len=16) "\tValid bool", + (string) (len=16) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=60) "func NewNullSanitizing(val interface{}) (x NullSanitizing) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=62) "func (x *NullSanitizing) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=46) "\t\tx.Sanitizing, x.Valid = Sanitizing(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=31) "\terr = x.Sanitizing.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=55) "func (x NullSanitizing) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=32) "\treturn int64(x.Sanitizing), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullSanitizing to JSON.", + (string) (len=55) "func (n NullSanitizing) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.Sanitizing)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullSanitizing from JSON.", + (string) (len=56) "func (n *NullSanitizing) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=31) "type NullSanitizingStr struct {", + (string) (len=15) "\tNullSanitizing", + (string) (len=1) "}", + (string) "", + (string) (len=66) "func NewNullSanitizingStr(val interface{}) (x NullSanitizingStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x NullSanitizingStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=34) "\treturn x.Sanitizing.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullSanitizing to JSON.", + (string) (len=58) "func (n NullSanitizingStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.Sanitizing)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullSanitizing from JSON.", + (string) (len=59) "func (n *NullSanitizingStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=46) "\t// Custom_prefix_Coke is a Soda of type Coke.", + (string) (len=31) "\tCustom_prefix_Coke Soda = iota", + (string) (len=48) "\t// Custom_prefix_Pepsi is a Soda of type Pepsi.", + (string) (len=20) "\tCustom_prefix_Pepsi", + (string) (len=50) "\t// Custom_prefix_MtnDew is a Soda of type MtnDew.", + (string) (len=21) "\tCustom_prefix_MtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=51) "var ErrInvalidSoda = errors.New(\"not a valid Soda\")", + (string) "", + (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=38) "\tCustom_prefix_Coke: _SodaName[0:4],", + (string) (len=38) "\tCustom_prefix_Pepsi: _SodaName[4:9],", + (string) (len=39) "\tCustom_prefix_MtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=54) "\t_SodaName[0:4]: Custom_prefix_Coke,", + (string) (len=54) "\tstrings.ToLower(_SodaName[0:4]): Custom_prefix_Coke,", + (string) (len=55) "\t_SodaName[4:9]: Custom_prefix_Pepsi,", + (string) (len=55) "\tstrings.ToLower(_SodaName[4:9]): Custom_prefix_Pepsi,", + (string) (len=56) "\t_SodaName[9:15]: Custom_prefix_MtnDew,", + (string) (len=56) "\tstrings.ToLower(_SodaName[9:15]): Custom_prefix_MtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=27) "func (x Soda) Ptr() *Soda {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=90) "var errSodaNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=52) "func (x *Soda) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=14) "\t\t*x = Soda(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase string:", + (string) (len=24) "\t\t*x, err = ParseSoda(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=28) "\t\t\t\t*x, err = Soda(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=32) "\t\t*x, err = ParseSoda(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=28) "\t\t\t\t*x, err = Soda(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=11) "\tcase Soda:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=12) "\tcase *Soda:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=25) "\t\t*x, err = ParseSoda(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=28) "\t\t\t\t*x, err = Soda(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=45) "func (x Soda) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=38) "func (x *Soda) Set(val string) error {", + (string) (len=25) "\tv, err := ParseSoda(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=34) "func (x *Soda) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=30) "func (x *Soda) Type() string {", + (string) (len=14) "\treturn \"Soda\"", + (string) (len=1) "}", + (string) "", + (string) (len=22) "type NullSoda struct {", + (string) (len=11) "\tSoda Soda", + (string) (len=11) "\tValid bool", + (string) (len=11) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=48) "func NewNullSoda(val interface{}) (x NullSoda) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=56) "func (x *NullSoda) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=34) "\t\tx.Soda, x.Valid = Soda(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=25) "\terr = x.Soda.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=49) "func (x NullSoda) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=26) "\treturn int64(x.Soda), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// MarshalJSON correctly serializes a NullSoda to JSON.", + (string) (len=49) "func (n NullSoda) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=29) "\t\treturn json.Marshal(n.Soda)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// UnmarshalJSON correctly deserializes a NullSoda from JSON.", + (string) (len=50) "func (n *NullSoda) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=25) "type NullSodaStr struct {", + (string) (len=9) "\tNullSoda", + (string) (len=1) "}", + (string) "", + (string) (len=54) "func NewNullSodaStr(val interface{}) (x NullSodaStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=52) "func (x NullSodaStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=28) "\treturn x.Soda.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// MarshalJSON correctly serializes a NullSoda to JSON.", + (string) (len=52) "func (n NullSodaStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=29) "\t\treturn json.Marshal(n.Soda)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// UnmarshalJSON correctly deserializes a NullSoda from JSON.", + (string) (len=53) "func (n *NullSodaStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=70) "\t// Custom_prefix_StartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=52) "\tCustom_prefix_StartWithNum StartNotZero = iota + 23", + (string) (len=60) "\t// Custom_prefix_NextNum is a StartNotZero of type NextNum.", + (string) (len=22) "\tCustom_prefix_NextNum", + (string) (len=1) ")", + (string) "", + (string) (len=67) "var ErrInvalidStartNotZero = errors.New(\"not a valid StartNotZero\")", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=53) "\tCustom_prefix_StartWithNum: _StartNotZeroName[0:12],", + (string) (len=54) "\tCustom_prefix_NextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=71) "\t_StartNotZeroName[0:12]: Custom_prefix_StartWithNum,", + (string) (len=71) "\tstrings.ToLower(_StartNotZeroName[0:12]): Custom_prefix_StartWithNum,", + (string) (len=66) "\t_StartNotZeroName[12:19]: Custom_prefix_NextNum,", + (string) (len=66) "\tstrings.ToLower(_StartNotZeroName[12:19]): Custom_prefix_NextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=43) "func (x StartNotZero) Ptr() *StartNotZero {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=98) "var errStartNotZeroNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=60) "func (x *StartNotZero) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=22) "\t\t*x = StartNotZero(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase string:", + (string) (len=32) "\t\t*x, err = ParseStartNotZero(v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=49) "\t\t\tif val, verr := strconv.Atoi(v); verr == nil {", + (string) (len=36) "\t\t\t\t*x, err = StartNotZero(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=13) "\tcase []byte:", + (string) (len=40) "\t\t*x, err = ParseStartNotZero(string(v))", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=57) "\t\t\tif val, verr := strconv.Atoi(string(v)); verr == nil {", + (string) (len=36) "\t\t\t\t*x, err = StartNotZero(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=19) "\tcase StartNotZero:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=20) "\tcase *StartNotZero:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=33) "\t\t*x, err = ParseStartNotZero(*v)", + (string) (len=17) "\t\tif err != nil {", + (string) (len=47) "\t\t\t// try parsing the integer value as a string", + (string) (len=50) "\t\t\tif val, verr := strconv.Atoi(*v); verr == nil {", + (string) (len=36) "\t\t\t\t*x, err = StartNotZero(val), nil", + (string) (len=4) "\t\t\t}", + (string) (len=3) "\t\t}", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x StartNotZero) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=46) "func (x *StartNotZero) Set(val string) error {", + (string) (len=33) "\tv, err := ParseStartNotZero(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=42) "func (x *StartNotZero) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=38) "func (x *StartNotZero) Type() string {", + (string) (len=22) "\treturn \"StartNotZero\"", + (string) (len=1) "}", + (string) "", + (string) (len=30) "type NullStartNotZero struct {", + (string) (len=26) "\tStartNotZero StartNotZero", + (string) (len=18) "\tValid bool", + (string) (len=18) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=64) "func NewNullStartNotZero(val interface{}) (x NullStartNotZero) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=64) "func (x *NullStartNotZero) Scan(value interface{}) (err error) {", + (string) (len=13) "\tx.Set = true", + (string) (len=18) "\tif value == nil {", + (string) (len=50) "\t\tx.StartNotZero, x.Valid = StartNotZero(0), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=33) "\terr = x.StartNotZero.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x NullStartNotZero) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=34) "\treturn int64(x.StartNotZero), nil", + (string) (len=1) "}", + (string) "", + (string) (len=63) "// MarshalJSON correctly serializes a NullStartNotZero to JSON.", + (string) (len=57) "func (n NullStartNotZero) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=37) "\t\treturn json.Marshal(n.StartNotZero)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=69) "// UnmarshalJSON correctly deserializes a NullStartNotZero from JSON.", + (string) (len=58) "func (n *NullStartNotZero) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=33) "type NullStartNotZeroStr struct {", + (string) (len=17) "\tNullStartNotZero", + (string) (len=1) "}", + (string) "", + (string) (len=70) "func NewNullStartNotZeroStr(val interface{}) (x NullStartNotZeroStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=60) "func (x NullStartNotZeroStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=36) "\treturn x.StartNotZero.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=63) "// MarshalJSON correctly serializes a NullStartNotZero to JSON.", + (string) (len=60) "func (n NullStartNotZeroStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=37) "\t\treturn json.Marshal(n.StartNotZero)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=69) "// UnmarshalJSON correctly deserializes a NullStartNotZero from JSON.", + (string) (len=61) "func (n *NullStartNotZeroStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// Custom_prefix_Random is a StringEnum of type random.", + (string) (len=43) "\tCustom_prefix_Random StringEnum = \"random\"", + (string) (len=56) "\t// Custom_prefix_Values is a StringEnum of type values.", + (string) (len=43) "\tCustom_prefix_Values StringEnum = \"values\"", + (string) (len=52) "\t// Custom_prefix_Here is a StringEnum of type here.", + (string) (len=39) "\tCustom_prefix_Here StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidStringEnum = errors.New(\"not a valid StringEnum\")", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=32) "\t\"random\": Custom_prefix_Random,", + (string) (len=32) "\t\"values\": Custom_prefix_Values,", + (string) (len=30) "\t\"here\": Custom_prefix_Here,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=39) "func (x StringEnum) Ptr() *StringEnum {", + (string) (len=10) "\treturn &x", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errStringEnumNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=47) "var sqlIntStringEnumMap = map[int64]StringEnum{", + (string) (len=28) "\t1114: Custom_prefix_Random,", + (string) (len=28) "\t300: Custom_prefix_Values,", + (string) (len=26) "\t1: Custom_prefix_Here,", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var sqlIntStringEnumValue = map[StringEnum]int64{", + (string) (len=28) "\tCustom_prefix_Random: 1114,", + (string) (len=27) "\tCustom_prefix_Values: 300,", + (string) (len=25) "\tCustom_prefix_Here: 1,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "func lookupSqlIntStringEnum(val int64) (StringEnum, error) {", + (string) (len=34) "\tx, ok := sqlIntStringEnumMap[val]", + (string) (len=9) "\tif !ok {", + (string) (len=65) "\t\treturn x, fmt.Errorf(\"%v is not %w\", val, ErrInvalidStringEnum)", + (string) (len=2) "\t}", + (string) (len=14) "\treturn x, nil", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=37) "\t\t*x, err = lookupSqlIntStringEnum(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=68) "\t\tif val, verr := strconv.ParseInt(string(v), 10, 64); verr == nil {", + (string) (len=40) "\t\t\t*x, err = lookupSqlIntStringEnum(val)", + (string) (len=10) "\t\t} else {", + (string) (len=39) "\t\t\t// try parsing the value as a string", + (string) (len=39) "\t\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=3) "\t\t}", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=13) "\tcase uint64:", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=44) "\t\t*x, err = lookupSqlIntStringEnum(int64(v))", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=45) "\t\t*x, err = lookupSqlIntStringEnum(int64(*v))", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=36) "\tval, ok := sqlIntStringEnumValue[x]", + (string) (len=9) "\tif !ok {", + (string) (len=34) "\t\treturn nil, ErrInvalidStringEnum", + (string) (len=2) "\t}", + (string) (len=23) "\treturn int64(val), nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *StringEnum) Set(val string) error {", + (string) (len=31) "\tv, err := ParseStringEnum(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *StringEnum) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *StringEnum) Type() string {", + (string) (len=20) "\treturn \"StringEnum\"", + (string) (len=1) "}", + (string) "", + (string) (len=28) "type NullStringEnum struct {", + (string) (len=22) "\tStringEnum StringEnum", + (string) (len=16) "\tValid bool", + (string) (len=16) "\tSet bool", + (string) (len=1) "}", + (string) "", + (string) (len=60) "func NewNullStringEnum(val interface{}) (x NullStringEnum) {", + (string) (len=83) "\terr := x.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=54) "\t_ = err // make any errcheck linters happy", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=62) "func (x *NullStringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=47) "\t\tx.StringEnum, x.Valid = StringEnum(\"\"), false", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=31) "\terr = x.StringEnum.Scan(value)", + (string) (len=23) "\tx.Valid = (err == nil)", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=55) "func (x NullStringEnum) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=46) "\t// driver.Value accepts int64 for int values.", + (string) (len=33) "\treturn string(x.StringEnum), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullStringEnum to JSON.", + (string) (len=55) "func (n NullStringEnum) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.StringEnum)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullStringEnum from JSON.", + (string) (len=56) "func (n *NullStringEnum) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=31) "type NullStringEnumStr struct {", + (string) (len=15) "\tNullStringEnum", + (string) (len=1) "}", + (string) "", + (string) (len=66) "func NewNullStringEnumStr(val interface{}) (x NullStringEnumStr) {", + (string) (len=76) "\tx.Scan(val) // yes, we ignore this error, it will just be an invalid value.", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x NullStringEnumStr) Value() (driver.Value, error) {", + (string) (len=14) "\tif !x.Valid {", + (string) (len=17) "\t\treturn nil, nil", + (string) (len=2) "\t}", + (string) (len=34) "\treturn x.StringEnum.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=61) "// MarshalJSON correctly serializes a NullStringEnum to JSON.", + (string) (len=58) "func (n NullStringEnumStr) MarshalJSON() ([]byte, error) {", + (string) (len=23) "\tconst nullStr = \"null\"", + (string) (len=13) "\tif n.Valid {", + (string) (len=35) "\t\treturn json.Marshal(n.StringEnum)", + (string) (len=2) "\t}", + (string) (len=28) "\treturn []byte(nullStr), nil", + (string) (len=1) "}", + (string) "", + (string) (len=67) "// UnmarshalJSON correctly deserializes a NullStringEnum from JSON.", + (string) (len=59) "func (n *NullStringEnumStr) UnmarshalJSON(b []byte) error {", + (string) (len=13) "\tn.Set = true", + (string) (len=18) "\tvar x interface{}", + (string) (len=29) "\terr := json.Unmarshal(b, &x)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=16) "\terr = n.Scan(x)", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/TestExampleFile b/generator/.snapshots/TestExampleFile new file mode 100644 index 00000000..cd0d19eb --- /dev/null +++ b/generator/.snapshots/TestExampleFile @@ -0,0 +1,2422 @@ +([]string) (len=2420) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=38) "\t// AnimalCat is a Animal of type Cat.", + (string) (len=24) "\tAnimalCat Animal = iota", + (string) (len=38) "\t// AnimalDog is a Animal of type Dog.", + (string) (len=10) "\tAnimalDog", + (string) (len=40) "\t// AnimalFish is a Animal of type Fish.", + (string) (len=11) "\tAnimalFish", + (string) (len=1) ")", + (string) "", + (string) (len=99) "var ErrInvalidAnimal = fmt.Errorf(\"not a valid Animal, try [%s]\", strings.Join(_AnimalNames, \", \"))", + (string) "", + (string) (len=32) "const _AnimalName = \"CatDogFish\"", + (string) "", + (string) (len=28) "var _AnimalNames = []string{", + (string) (len=18) "\t_AnimalName[0:3],", + (string) (len=18) "\t_AnimalName[3:6],", + (string) (len=19) "\t_AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// AnimalNames returns a list of possible string values of Animal.", + (string) (len=29) "func AnimalNames() []string {", + (string) (len=41) "\ttmp := make([]string, len(_AnimalNames))", + (string) (len=24) "\tcopy(tmp, _AnimalNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=30) "\tAnimalCat: _AnimalName[0:3],", + (string) (len=30) "\tAnimalDog: _AnimalName[3:6],", + (string) (len=31) "\tAnimalFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=47) "\t_AnimalName[0:3]: AnimalCat,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[0:3]): AnimalCat,", + (string) (len=47) "\t_AnimalName[3:6]: AnimalDog,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[3:6]): AnimalDog,", + (string) (len=48) "\t_AnimalName[6:10]: AnimalFish,", + (string) (len=48) "\tstrings.ToLower(_AnimalName[6:10]): AnimalFish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=54) "\tif x, ok := _AnimalValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=92) "var errAnimalNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=54) "func (x *Animal) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=16) "\t\t*x = Animal(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase string:", + (string) (len=26) "\t\t*x, err = ParseAnimal(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=34) "\t\t*x, err = ParseAnimal(string(v))", + (string) (len=13) "\tcase Animal:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=14) "\tcase *Animal:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x, err = ParseAnimal(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=47) "func (x Animal) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=50) "\t// CasesTest_lower is a Cases of type Test_lower.", + (string) (len=29) "\tCasesTest_lower Cases = iota", + (string) (len=54) "\t// CasesTest_capital is a Cases of type Test_capital.", + (string) (len=18) "\tCasesTest_capital", + (string) (len=72) "\t// CasesAnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=27) "\tCasesAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidCases = fmt.Errorf(\"not a valid Cases, try [%s]\", strings.Join(_CasesNames, \", \"))", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", + (string) "", + (string) (len=27) "var _CasesNames = []string{", + (string) (len=18) "\t_CasesName[0:10],", + (string) (len=19) "\t_CasesName[10:22],", + (string) (len=19) "\t_CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// CasesNames returns a list of possible string values of Cases.", + (string) (len=28) "func CasesNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_CasesNames))", + (string) (len=23) "\tcopy(tmp, _CasesNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=46) "\tCasesTest_lower: _CasesName[0:10],", + (string) (len=47) "\tCasesTest_capital: _CasesName[10:22],", + (string) (len=47) "\tCasesAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=53) "\t_CasesName[0:10]: CasesTest_lower,", + (string) (len=53) "\tstrings.ToLower(_CasesName[0:10]): CasesTest_lower,", + (string) (len=55) "\t_CasesName[10:22]: CasesTest_capital,", + (string) (len=55) "\tstrings.ToLower(_CasesName[10:22]): CasesTest_capital,", + (string) (len=64) "\t_CasesName[22:43]: CasesAnotherLowerCaseStart,", + (string) (len=64) "\tstrings.ToLower(_CasesName[22:43]): CasesAnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _CasesValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errCasesNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Cases) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Cases(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseCases(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseCases(string(v))", + (string) (len=12) "\tcase Cases:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase *Cases:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseCases(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Cases) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=40) "\t// ColorBlack is a Color of type Black.", + (string) (len=24) "\tColorBlack Color = iota", + (string) (len=40) "\t// ColorWhite is a Color of type White.", + (string) (len=11) "\tColorWhite", + (string) (len=36) "\t// ColorRed is a Color of type Red.", + (string) (len=9) "\tColorRed", + (string) (len=40) "\t// ColorGreen is a Color of type Green.", + (string) (len=11) "\tColorGreen", + (string) (len=38) "\t// ColorBlue is a Color of type Blue.", + (string) (len=28) "\tColorBlue Color = iota + 29", + (string) (len=38) "\t// ColorGrey is a Color of type Grey.", + (string) (len=10) "\tColorGrey", + (string) (len=42) "\t// ColorYellow is a Color of type Yellow.", + (string) (len=12) "\tColorYellow", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidColor = fmt.Errorf(\"not a valid Color, try [%s]\", strings.Join(_ColorNames, \", \"))", + (string) "", + (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=27) "var _ColorNames = []string{", + (string) (len=17) "\t_ColorName[0:5],", + (string) (len=18) "\t_ColorName[5:10],", + (string) (len=19) "\t_ColorName[10:13],", + (string) (len=19) "\t_ColorName[13:18],", + (string) (len=19) "\t_ColorName[18:22],", + (string) (len=19) "\t_ColorName[22:26],", + (string) (len=19) "\t_ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ColorNames returns a list of possible string values of Color.", + (string) (len=28) "func ColorNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ColorNames))", + (string) (len=23) "\tcopy(tmp, _ColorNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=30) "\tColorBlack: _ColorName[0:5],", + (string) (len=31) "\tColorWhite: _ColorName[5:10],", + (string) (len=32) "\tColorRed: _ColorName[10:13],", + (string) (len=32) "\tColorGreen: _ColorName[13:18],", + (string) (len=32) "\tColorBlue: _ColorName[18:22],", + (string) (len=32) "\tColorGrey: _ColorName[22:26],", + (string) (len=32) "\tColorYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=48) "\t_ColorName[0:5]: ColorBlack,", + (string) (len=48) "\tstrings.ToLower(_ColorName[0:5]): ColorBlack,", + (string) (len=48) "\t_ColorName[5:10]: ColorWhite,", + (string) (len=48) "\tstrings.ToLower(_ColorName[5:10]): ColorWhite,", + (string) (len=46) "\t_ColorName[10:13]: ColorRed,", + (string) (len=46) "\tstrings.ToLower(_ColorName[10:13]): ColorRed,", + (string) (len=48) "\t_ColorName[13:18]: ColorGreen,", + (string) (len=48) "\tstrings.ToLower(_ColorName[13:18]): ColorGreen,", + (string) (len=47) "\t_ColorName[18:22]: ColorBlue,", + (string) (len=47) "\tstrings.ToLower(_ColorName[18:22]): ColorBlue,", + (string) (len=47) "\t_ColorName[22:26]: ColorGrey,", + (string) (len=47) "\tstrings.ToLower(_ColorName[22:26]): ColorGrey,", + (string) (len=49) "\t_ColorName[26:32]: ColorYellow,", + (string) (len=49) "\tstrings.ToLower(_ColorName[26:32]): ColorYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _ColorValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errColorNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Color) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Color(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseColor(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseColor(string(v))", + (string) (len=12) "\tcase Color:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase *Color:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseColor(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Color) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=62) "\t// ColorWithCommentBlack is a ColorWithComment of type Black.", + (string) (len=46) "\tColorWithCommentBlack ColorWithComment = iota", + (string) (len=62) "\t// ColorWithCommentWhite is a ColorWithComment of type White.", + (string) (len=22) "\tColorWithCommentWhite", + (string) (len=58) "\t// ColorWithCommentRed is a ColorWithComment of type Red.", + (string) (len=20) "\tColorWithCommentRed", + (string) (len=62) "\t// ColorWithCommentGreen is a ColorWithComment of type Green.", + (string) (len=22) "\tColorWithCommentGreen", + (string) (len=60) "\t// ColorWithCommentBlue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=50) "\tColorWithCommentBlue ColorWithComment = iota + 29", + (string) (len=60) "\t// ColorWithCommentGrey is a ColorWithComment of type Grey.", + (string) (len=21) "\tColorWithCommentGrey", + (string) (len=64) "\t// ColorWithCommentYellow is a ColorWithComment of type Yellow.", + (string) (len=23) "\tColorWithCommentYellow", + (string) (len=1) ")", + (string) "", + (string) (len=129) "var ErrInvalidColorWithComment = fmt.Errorf(\"not a valid ColorWithComment, try [%s]\", strings.Join(_ColorWithCommentNames, \", \"))", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=38) "var _ColorWithCommentNames = []string{", + (string) (len=28) "\t_ColorWithCommentName[0:5],", + (string) (len=29) "\t_ColorWithCommentName[5:10],", + (string) (len=30) "\t_ColorWithCommentName[10:13],", + (string) (len=30) "\t_ColorWithCommentName[13:18],", + (string) (len=30) "\t_ColorWithCommentName[18:22],", + (string) (len=30) "\t_ColorWithCommentName[22:26],", + (string) (len=30) "\t_ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=86) "// ColorWithCommentNames returns a list of possible string values of ColorWithComment.", + (string) (len=39) "func ColorWithCommentNames() []string {", + (string) (len=51) "\ttmp := make([]string, len(_ColorWithCommentNames))", + (string) (len=34) "\tcopy(tmp, _ColorWithCommentNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=52) "\tColorWithCommentBlack: _ColorWithCommentName[0:5],", + (string) (len=53) "\tColorWithCommentWhite: _ColorWithCommentName[5:10],", + (string) (len=54) "\tColorWithCommentRed: _ColorWithCommentName[10:13],", + (string) (len=54) "\tColorWithCommentGreen: _ColorWithCommentName[13:18],", + (string) (len=54) "\tColorWithCommentBlue: _ColorWithCommentName[18:22],", + (string) (len=54) "\tColorWithCommentGrey: _ColorWithCommentName[22:26],", + (string) (len=54) "\tColorWithCommentYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=70) "\t_ColorWithCommentName[0:5]: ColorWithCommentBlack,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[0:5]): ColorWithCommentBlack,", + (string) (len=70) "\t_ColorWithCommentName[5:10]: ColorWithCommentWhite,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[5:10]): ColorWithCommentWhite,", + (string) (len=68) "\t_ColorWithCommentName[10:13]: ColorWithCommentRed,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[10:13]): ColorWithCommentRed,", + (string) (len=70) "\t_ColorWithCommentName[13:18]: ColorWithCommentGreen,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[13:18]): ColorWithCommentGreen,", + (string) (len=69) "\t_ColorWithCommentName[18:22]: ColorWithCommentBlue,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[18:22]): ColorWithCommentBlue,", + (string) (len=69) "\t_ColorWithCommentName[22:26]: ColorWithCommentGrey,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[22:26]): ColorWithCommentGrey,", + (string) (len=71) "\t_ColorWithCommentName[26:32]: ColorWithCommentYellow,", + (string) (len=71) "\tstrings.ToLower(_ColorWithCommentName[26:32]): ColorWithCommentYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=64) "\tif x, ok := _ColorWithCommentValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=102) "var errColorWithCommentNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=64) "func (x *ColorWithComment) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=26) "\t\t*x = ColorWithComment(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase string:", + (string) (len=36) "\t\t*x, err = ParseColorWithComment(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=44) "\t\t*x, err = ParseColorWithComment(string(v))", + (string) (len=23) "\tcase ColorWithComment:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=24) "\tcase *ColorWithComment:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=37) "\t\t*x, err = ParseColorWithComment(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x ColorWithComment) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment2Black is a ColorWithComment2 of type Black.", + (string) (len=48) "\tColorWithComment2Black ColorWithComment2 = iota", + (string) (len=64) "\t// ColorWithComment2White is a ColorWithComment2 of type White.", + (string) (len=23) "\tColorWithComment2White", + (string) (len=60) "\t// ColorWithComment2Red is a ColorWithComment2 of type Red.", + (string) (len=21) "\tColorWithComment2Red", + (string) (len=64) "\t// ColorWithComment2Green is a ColorWithComment2 of type Green.", + (string) (len=23) "\tColorWithComment2Green", + (string) (len=62) "\t// ColorWithComment2Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=52) "\tColorWithComment2Blue ColorWithComment2 = iota + 29", + (string) (len=62) "\t// ColorWithComment2Grey is a ColorWithComment2 of type Grey.", + (string) (len=22) "\tColorWithComment2Grey", + (string) (len=66) "\t// ColorWithComment2Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=24) "\tColorWithComment2Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment2 = fmt.Errorf(\"not a valid ColorWithComment2, try [%s]\", strings.Join(_ColorWithComment2Names, \", \"))", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=39) "var _ColorWithComment2Names = []string{", + (string) (len=29) "\t_ColorWithComment2Name[0:5],", + (string) (len=30) "\t_ColorWithComment2Name[5:10],", + (string) (len=31) "\t_ColorWithComment2Name[10:13],", + (string) (len=31) "\t_ColorWithComment2Name[13:18],", + (string) (len=31) "\t_ColorWithComment2Name[18:22],", + (string) (len=31) "\t_ColorWithComment2Name[22:26],", + (string) (len=31) "\t_ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment2Names returns a list of possible string values of ColorWithComment2.", + (string) (len=40) "func ColorWithComment2Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment2Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment2Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=54) "\tColorWithComment2Black: _ColorWithComment2Name[0:5],", + (string) (len=55) "\tColorWithComment2White: _ColorWithComment2Name[5:10],", + (string) (len=56) "\tColorWithComment2Red: _ColorWithComment2Name[10:13],", + (string) (len=56) "\tColorWithComment2Green: _ColorWithComment2Name[13:18],", + (string) (len=56) "\tColorWithComment2Blue: _ColorWithComment2Name[18:22],", + (string) (len=56) "\tColorWithComment2Grey: _ColorWithComment2Name[22:26],", + (string) (len=56) "\tColorWithComment2Yellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=72) "\t_ColorWithComment2Name[0:5]: ColorWithComment2Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): ColorWithComment2Black,", + (string) (len=72) "\t_ColorWithComment2Name[5:10]: ColorWithComment2White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): ColorWithComment2White,", + (string) (len=70) "\t_ColorWithComment2Name[10:13]: ColorWithComment2Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): ColorWithComment2Red,", + (string) (len=72) "\t_ColorWithComment2Name[13:18]: ColorWithComment2Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): ColorWithComment2Green,", + (string) (len=71) "\t_ColorWithComment2Name[18:22]: ColorWithComment2Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): ColorWithComment2Blue,", + (string) (len=71) "\t_ColorWithComment2Name[22:26]: ColorWithComment2Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): ColorWithComment2Grey,", + (string) (len=73) "\t_ColorWithComment2Name[26:32]: ColorWithComment2Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): ColorWithComment2Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment2Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment2NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment2) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment2(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment2(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment2(string(v))", + (string) (len=24) "\tcase ColorWithComment2:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=25) "\tcase *ColorWithComment2:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment2(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment2) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment3Black is a ColorWithComment3 of type Black.", + (string) (len=48) "\tColorWithComment3Black ColorWithComment3 = iota", + (string) (len=64) "\t// ColorWithComment3White is a ColorWithComment3 of type White.", + (string) (len=23) "\tColorWithComment3White", + (string) (len=60) "\t// ColorWithComment3Red is a ColorWithComment3 of type Red.", + (string) (len=21) "\tColorWithComment3Red", + (string) (len=64) "\t// ColorWithComment3Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment3Green ColorWithComment3 = iota + 30", + (string) (len=62) "\t// ColorWithComment3Blue is a ColorWithComment3 of type Blue.", + (string) (len=22) "\tColorWithComment3Blue", + (string) (len=62) "\t// ColorWithComment3Grey is a ColorWithComment3 of type Grey.", + (string) (len=22) "\tColorWithComment3Grey", + (string) (len=66) "\t// ColorWithComment3Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=24) "\tColorWithComment3Yellow", + (string) (len=73) "\t// ColorWithComment3BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment3BlueGreen", + (string) (len=73) "\t// ColorWithComment3RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=27) "\tColorWithComment3RedOrange", + (string) (len=82) "\t// ColorWithComment3RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=31) "\tColorWithComment3RedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment3 = fmt.Errorf(\"not a valid ColorWithComment3, try [%s]\", strings.Join(_ColorWithComment3Names, \", \"))", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=39) "var _ColorWithComment3Names = []string{", + (string) (len=29) "\t_ColorWithComment3Name[0:5],", + (string) (len=30) "\t_ColorWithComment3Name[5:10],", + (string) (len=31) "\t_ColorWithComment3Name[10:13],", + (string) (len=31) "\t_ColorWithComment3Name[13:18],", + (string) (len=31) "\t_ColorWithComment3Name[18:22],", + (string) (len=31) "\t_ColorWithComment3Name[22:26],", + (string) (len=31) "\t_ColorWithComment3Name[26:32],", + (string) (len=31) "\t_ColorWithComment3Name[32:42],", + (string) (len=31) "\t_ColorWithComment3Name[42:52],", + (string) (len=31) "\t_ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment3Names returns a list of possible string values of ColorWithComment3.", + (string) (len=40) "func ColorWithComment3Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment3Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment3Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=61) "\tColorWithComment3Black: _ColorWithComment3Name[0:5],", + (string) (len=62) "\tColorWithComment3White: _ColorWithComment3Name[5:10],", + (string) (len=63) "\tColorWithComment3Red: _ColorWithComment3Name[10:13],", + (string) (len=63) "\tColorWithComment3Green: _ColorWithComment3Name[13:18],", + (string) (len=63) "\tColorWithComment3Blue: _ColorWithComment3Name[18:22],", + (string) (len=63) "\tColorWithComment3Grey: _ColorWithComment3Name[22:26],", + (string) (len=63) "\tColorWithComment3Yellow: _ColorWithComment3Name[26:32],", + (string) (len=63) "\tColorWithComment3BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=63) "\tColorWithComment3RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=63) "\tColorWithComment3RedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=72) "\t_ColorWithComment3Name[0:5]: ColorWithComment3Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): ColorWithComment3Black,", + (string) (len=72) "\t_ColorWithComment3Name[5:10]: ColorWithComment3White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): ColorWithComment3White,", + (string) (len=70) "\t_ColorWithComment3Name[10:13]: ColorWithComment3Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): ColorWithComment3Red,", + (string) (len=72) "\t_ColorWithComment3Name[13:18]: ColorWithComment3Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): ColorWithComment3Green,", + (string) (len=71) "\t_ColorWithComment3Name[18:22]: ColorWithComment3Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): ColorWithComment3Blue,", + (string) (len=71) "\t_ColorWithComment3Name[22:26]: ColorWithComment3Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): ColorWithComment3Grey,", + (string) (len=73) "\t_ColorWithComment3Name[26:32]: ColorWithComment3Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): ColorWithComment3Yellow,", + (string) (len=76) "\t_ColorWithComment3Name[32:42]: ColorWithComment3BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): ColorWithComment3BlueGreen,", + (string) (len=76) "\t_ColorWithComment3Name[42:52]: ColorWithComment3RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): ColorWithComment3RedOrange,", + (string) (len=80) "\t_ColorWithComment3Name[52:67]: ColorWithComment3RedOrangeBlue,", + (string) (len=80) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): ColorWithComment3RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment3Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment3NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment3) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment3(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment3(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment3(string(v))", + (string) (len=24) "\tcase ColorWithComment3:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=25) "\tcase *ColorWithComment3:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment3(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment3) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=64) "\t// ColorWithComment4Black is a ColorWithComment4 of type Black.", + (string) (len=23) "\tColorWithComment4Black", + (string) (len=64) "\t// ColorWithComment4White is a ColorWithComment4 of type White.", + (string) (len=23) "\tColorWithComment4White", + (string) (len=60) "\t// ColorWithComment4Red is a ColorWithComment4 of type Red.", + (string) (len=21) "\tColorWithComment4Red", + (string) (len=64) "\t// ColorWithComment4Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment4Green ColorWithComment4 = iota + 29", + (string) (len=62) "\t// ColorWithComment4Blue is a ColorWithComment4 of type Blue.", + (string) (len=22) "\tColorWithComment4Blue", + (string) (len=62) "\t// ColorWithComment4Grey is a ColorWithComment4 of type Grey.", + (string) (len=22) "\tColorWithComment4Grey", + (string) (len=66) "\t// ColorWithComment4Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=24) "\tColorWithComment4Yellow", + (string) (len=73) "\t// ColorWithComment4BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment4BlueGreen", + (string) (len=73) "\t// ColorWithComment4RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=27) "\tColorWithComment4RedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment4 = fmt.Errorf(\"not a valid ColorWithComment4, try [%s]\", strings.Join(_ColorWithComment4Names, \", \"))", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=39) "var _ColorWithComment4Names = []string{", + (string) (len=29) "\t_ColorWithComment4Name[0:5],", + (string) (len=30) "\t_ColorWithComment4Name[5:10],", + (string) (len=31) "\t_ColorWithComment4Name[10:13],", + (string) (len=31) "\t_ColorWithComment4Name[13:18],", + (string) (len=31) "\t_ColorWithComment4Name[18:22],", + (string) (len=31) "\t_ColorWithComment4Name[22:26],", + (string) (len=31) "\t_ColorWithComment4Name[26:32],", + (string) (len=31) "\t_ColorWithComment4Name[32:42],", + (string) (len=31) "\t_ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment4Names returns a list of possible string values of ColorWithComment4.", + (string) (len=40) "func ColorWithComment4Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment4Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment4Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=57) "\tColorWithComment4Black: _ColorWithComment4Name[0:5],", + (string) (len=58) "\tColorWithComment4White: _ColorWithComment4Name[5:10],", + (string) (len=59) "\tColorWithComment4Red: _ColorWithComment4Name[10:13],", + (string) (len=59) "\tColorWithComment4Green: _ColorWithComment4Name[13:18],", + (string) (len=59) "\tColorWithComment4Blue: _ColorWithComment4Name[18:22],", + (string) (len=59) "\tColorWithComment4Grey: _ColorWithComment4Name[22:26],", + (string) (len=59) "\tColorWithComment4Yellow: _ColorWithComment4Name[26:32],", + (string) (len=59) "\tColorWithComment4BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=59) "\tColorWithComment4RedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=72) "\t_ColorWithComment4Name[0:5]: ColorWithComment4Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): ColorWithComment4Black,", + (string) (len=72) "\t_ColorWithComment4Name[5:10]: ColorWithComment4White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): ColorWithComment4White,", + (string) (len=70) "\t_ColorWithComment4Name[10:13]: ColorWithComment4Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): ColorWithComment4Red,", + (string) (len=72) "\t_ColorWithComment4Name[13:18]: ColorWithComment4Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): ColorWithComment4Green,", + (string) (len=71) "\t_ColorWithComment4Name[18:22]: ColorWithComment4Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): ColorWithComment4Blue,", + (string) (len=71) "\t_ColorWithComment4Name[22:26]: ColorWithComment4Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): ColorWithComment4Grey,", + (string) (len=73) "\t_ColorWithComment4Name[26:32]: ColorWithComment4Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): ColorWithComment4Yellow,", + (string) (len=76) "\t_ColorWithComment4Name[32:42]: ColorWithComment4BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): ColorWithComment4BlueGreen,", + (string) (len=76) "\t_ColorWithComment4Name[42:52]: ColorWithComment4RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): ColorWithComment4RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment4Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment4NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment4) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment4(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment4(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment4(string(v))", + (string) (len=24) "\tcase ColorWithComment4:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=25) "\tcase *ColorWithComment4:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment4(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment4) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Enum64bitUnknown is a Enum64bit of type Unknown.", + (string) (len=34) "\tEnum64bitUnknown Enum64bit = iota", + (string) (len=48) "\t// Enum64bitE2P15 is a Enum64bit of type E2P15.", + (string) (len=40) "\tEnum64bitE2P15 Enum64bit = iota + 32767", + (string) (len=48) "\t// Enum64bitE2P16 is a Enum64bit of type E2P16.", + (string) (len=40) "\tEnum64bitE2P16 Enum64bit = iota + 65534", + (string) (len=48) "\t// Enum64bitE2P17 is a Enum64bit of type E2P17.", + (string) (len=41) "\tEnum64bitE2P17 Enum64bit = iota + 131069", + (string) (len=48) "\t// Enum64bitE2P18 is a Enum64bit of type E2P18.", + (string) (len=41) "\tEnum64bitE2P18 Enum64bit = iota + 262140", + (string) (len=48) "\t// Enum64bitE2P19 is a Enum64bit of type E2P19.", + (string) (len=41) "\tEnum64bitE2P19 Enum64bit = iota + 524283", + (string) (len=48) "\t// Enum64bitE2P20 is a Enum64bit of type E2P20.", + (string) (len=42) "\tEnum64bitE2P20 Enum64bit = iota + 1048570", + (string) (len=48) "\t// Enum64bitE2P21 is a Enum64bit of type E2P21.", + (string) (len=42) "\tEnum64bitE2P21 Enum64bit = iota + 2097145", + (string) (len=48) "\t// Enum64bitE2P22 is a Enum64bit of type E2P22.", + (string) (len=43) "\tEnum64bitE2P22 Enum64bit = iota + 33554424", + (string) (len=48) "\t// Enum64bitE2P23 is a Enum64bit of type E2P23.", + (string) (len=43) "\tEnum64bitE2P23 Enum64bit = iota + 67108855", + (string) (len=48) "\t// Enum64bitE2P28 is a Enum64bit of type E2P28.", + (string) (len=44) "\tEnum64bitE2P28 Enum64bit = iota + 536870902", + (string) (len=48) "\t// Enum64bitE2P30 is a Enum64bit of type E2P30.", + (string) (len=45) "\tEnum64bitE2P30 Enum64bit = iota + 1073741813", + (string) (len=48) "\t// Enum64bitE2P31 is a Enum64bit of type E2P31.", + (string) (len=45) "\tEnum64bitE2P31 Enum64bit = iota + 2147483636", + (string) (len=48) "\t// Enum64bitE2P32 is a Enum64bit of type E2P32.", + (string) (len=45) "\tEnum64bitE2P32 Enum64bit = iota + 4294967283", + (string) (len=48) "\t// Enum64bitE2P33 is a Enum64bit of type E2P33.", + (string) (len=45) "\tEnum64bitE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=108) "var ErrInvalidEnum64bit = fmt.Errorf(\"not a valid Enum64bit, try [%s]\", strings.Join(_Enum64bitNames, \", \"))", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=31) "var _Enum64bitNames = []string{", + (string) (len=21) "\t_Enum64bitName[0:7],", + (string) (len=22) "\t_Enum64bitName[7:12],", + (string) (len=23) "\t_Enum64bitName[12:17],", + (string) (len=23) "\t_Enum64bitName[17:22],", + (string) (len=23) "\t_Enum64bitName[22:27],", + (string) (len=23) "\t_Enum64bitName[27:32],", + (string) (len=23) "\t_Enum64bitName[32:37],", + (string) (len=23) "\t_Enum64bitName[37:42],", + (string) (len=23) "\t_Enum64bitName[42:47],", + (string) (len=23) "\t_Enum64bitName[47:52],", + (string) (len=23) "\t_Enum64bitName[52:57],", + (string) (len=23) "\t_Enum64bitName[57:62],", + (string) (len=23) "\t_Enum64bitName[62:67],", + (string) (len=23) "\t_Enum64bitName[67:72],", + (string) (len=23) "\t_Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=72) "// Enum64bitNames returns a list of possible string values of Enum64bit.", + (string) (len=32) "func Enum64bitNames() []string {", + (string) (len=44) "\ttmp := make([]string, len(_Enum64bitNames))", + (string) (len=27) "\tcopy(tmp, _Enum64bitNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=39) "\tEnum64bitUnknown: _Enum64bitName[0:7],", + (string) (len=40) "\tEnum64bitE2P15: _Enum64bitName[7:12],", + (string) (len=41) "\tEnum64bitE2P16: _Enum64bitName[12:17],", + (string) (len=41) "\tEnum64bitE2P17: _Enum64bitName[17:22],", + (string) (len=41) "\tEnum64bitE2P18: _Enum64bitName[22:27],", + (string) (len=41) "\tEnum64bitE2P19: _Enum64bitName[27:32],", + (string) (len=41) "\tEnum64bitE2P20: _Enum64bitName[32:37],", + (string) (len=41) "\tEnum64bitE2P21: _Enum64bitName[37:42],", + (string) (len=41) "\tEnum64bitE2P22: _Enum64bitName[42:47],", + (string) (len=41) "\tEnum64bitE2P23: _Enum64bitName[47:52],", + (string) (len=41) "\tEnum64bitE2P28: _Enum64bitName[52:57],", + (string) (len=41) "\tEnum64bitE2P30: _Enum64bitName[57:62],", + (string) (len=41) "\tEnum64bitE2P31: _Enum64bitName[62:67],", + (string) (len=41) "\tEnum64bitE2P32: _Enum64bitName[67:72],", + (string) (len=41) "\tEnum64bitE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=58) "\t_Enum64bitName[0:7]: Enum64bitUnknown,", + (string) (len=58) "\tstrings.ToLower(_Enum64bitName[0:7]): Enum64bitUnknown,", + (string) (len=56) "\t_Enum64bitName[7:12]: Enum64bitE2P15,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[7:12]): Enum64bitE2P15,", + (string) (len=56) "\t_Enum64bitName[12:17]: Enum64bitE2P16,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[12:17]): Enum64bitE2P16,", + (string) (len=56) "\t_Enum64bitName[17:22]: Enum64bitE2P17,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[17:22]): Enum64bitE2P17,", + (string) (len=56) "\t_Enum64bitName[22:27]: Enum64bitE2P18,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[22:27]): Enum64bitE2P18,", + (string) (len=56) "\t_Enum64bitName[27:32]: Enum64bitE2P19,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[27:32]): Enum64bitE2P19,", + (string) (len=56) "\t_Enum64bitName[32:37]: Enum64bitE2P20,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[32:37]): Enum64bitE2P20,", + (string) (len=56) "\t_Enum64bitName[37:42]: Enum64bitE2P21,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[37:42]): Enum64bitE2P21,", + (string) (len=56) "\t_Enum64bitName[42:47]: Enum64bitE2P22,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[42:47]): Enum64bitE2P22,", + (string) (len=56) "\t_Enum64bitName[47:52]: Enum64bitE2P23,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[47:52]): Enum64bitE2P23,", + (string) (len=56) "\t_Enum64bitName[52:57]: Enum64bitE2P28,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[52:57]): Enum64bitE2P28,", + (string) (len=56) "\t_Enum64bitName[57:62]: Enum64bitE2P30,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[57:62]): Enum64bitE2P30,", + (string) (len=56) "\t_Enum64bitName[62:67]: Enum64bitE2P31,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[62:67]): Enum64bitE2P31,", + (string) (len=56) "\t_Enum64bitName[67:72]: Enum64bitE2P32,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[67:72]): Enum64bitE2P32,", + (string) (len=56) "\t_Enum64bitName[72:77]: Enum64bitE2P33,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[72:77]): Enum64bitE2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=57) "\tif x, ok := _Enum64bitValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=95) "var errEnum64bitNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *Enum64bit) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=19) "\t\t*x = Enum64bit(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase string:", + (string) (len=29) "\t\t*x, err = ParseEnum64bit(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=37) "\t\t*x, err = ParseEnum64bit(string(v))", + (string) (len=16) "\tcase Enum64bit:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=17) "\tcase *Enum64bit:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=30) "\t\t*x, err = ParseEnum64bit(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x Enum64bit) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// ModelToyota is a Model of type Toyota.", + (string) (len=25) "\tModelToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=40) "\t// ModelChevy is a Model of type Chevy.", + (string) (len=11) "\tModelChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=38) "\t// ModelFord is a Model of type Ford.", + (string) (len=10) "\tModelFord", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidModel = fmt.Errorf(\"not a valid Model, try [%s]\", strings.Join(_ModelNames, \", \"))", + (string) "", + (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", + (string) "", + (string) (len=27) "var _ModelNames = []string{", + (string) (len=17) "\t_ModelName[0:6],", + (string) (len=18) "\t_ModelName[6:11],", + (string) (len=19) "\t_ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ModelNames returns a list of possible string values of Model.", + (string) (len=28) "func ModelNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ModelNames))", + (string) (len=23) "\tcopy(tmp, _ModelNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=30) "\tModelToyota: _ModelName[0:6],", + (string) (len=31) "\tModelChevy: _ModelName[6:11],", + (string) (len=32) "\tModelFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=49) "\t_ModelName[0:6]: ModelToyota,", + (string) (len=49) "\tstrings.ToLower(_ModelName[0:6]): ModelToyota,", + (string) (len=48) "\t_ModelName[6:11]: ModelChevy,", + (string) (len=48) "\tstrings.ToLower(_ModelName[6:11]): ModelChevy,", + (string) (len=47) "\t_ModelName[11:15]: ModelFord,", + (string) (len=47) "\tstrings.ToLower(_ModelName[11:15]): ModelFord,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _ModelValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errModelNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Model) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Model(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseModel(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseModel(string(v))", + (string) (len=12) "\tcase Model:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase *Model:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseModel(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Model) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=60) "\t// NonASCIIПродам is a NonASCII of type Продам.", + (string) (len=44) "\tNonASCIIПродам NonASCII = iota + 1114", + (string) (len=48) "\t// NonASCII車庫 is a NonASCII of type 車庫.", + (string) (len=37) "\tNonASCII車庫 NonASCII = iota + 299", + (string) (len=52) "\t// NonASCIIԷժան is a NonASCII of type Էժան.", + (string) (len=38) "\tNonASCIIԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=105) "var ErrInvalidNonASCII = fmt.Errorf(\"not a valid NonASCII, try [%s]\", strings.Join(_NonASCIINames, \", \"))", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=30) "var _NonASCIINames = []string{", + (string) (len=21) "\t_NonASCIIName[0:12],", + (string) (len=22) "\t_NonASCIIName[12:18],", + (string) (len=22) "\t_NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=70) "// NonASCIINames returns a list of possible string values of NonASCII.", + (string) (len=31) "func NonASCIINames() []string {", + (string) (len=43) "\ttmp := make([]string, len(_NonASCIINames))", + (string) (len=26) "\tcopy(tmp, _NonASCIINames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=43) "\tNonASCIIПродам: _NonASCIIName[0:12],", + (string) (len=42) "\tNonASCII車庫: _NonASCIIName[12:18],", + (string) (len=42) "\tNonASCIIԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=61) "\t_NonASCIIName[0:12]: NonASCIIПродам,", + (string) (len=61) "\tstrings.ToLower(_NonASCIIName[0:12]): NonASCIIПродам,", + (string) (len=55) "\t_NonASCIIName[12:18]: NonASCII車庫,", + (string) (len=55) "\tstrings.ToLower(_NonASCIIName[12:18]): NonASCII車庫,", + (string) (len=57) "\t_NonASCIIName[18:26]: NonASCIIԷժան,", + (string) (len=57) "\tstrings.ToLower(_NonASCIIName[18:26]): NonASCIIԷժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=56) "\tif x, ok := _NonASCIIValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=94) "var errNonASCIINilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=56) "func (x *NonASCII) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=18) "\t\t*x = NonASCII(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase string:", + (string) (len=28) "\t\t*x, err = ParseNonASCII(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=36) "\t\t*x, err = ParseNonASCII(string(v))", + (string) (len=15) "\tcase NonASCII:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=16) "\tcase *NonASCII:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=29) "\t\t*x, err = ParseNonASCII(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=49) "func (x NonASCII) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=61) "\t// SanitizingTestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=39) "\tSanitizingTestHyphen Sanitizing = iota", + (string) (len=63) "\t// SanitizingHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=22) "\tSanitizingHyphenStart", + (string) (len=72) "\t// Sanitizing_UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=27) "\tSanitizing_UnderscoreFirst", + (string) (len=64) "\t// Sanitizing0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=23) "\tSanitizing0NumberFirst", + (string) (len=60) "\t// Sanitizing123456789A is a Sanitizing of type 123456789A.", + (string) (len=21) "\tSanitizing123456789A", + (string) (len=61) "\t// Sanitizing123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=21) "\tSanitizing123123Asdf", + (string) (len=66) "\t// SanitizingEndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=23) "\tSanitizingEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidSanitizing = fmt.Errorf(\"not a valid Sanitizing, try [%s]\", strings.Join(_SanitizingNames, \", \"))", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=32) "var _SanitizingNames = []string{", + (string) (len=23) "\t_SanitizingName[0:11],", + (string) (len=24) "\t_SanitizingName[11:23],", + (string) (len=24) "\t_SanitizingName[23:39],", + (string) (len=24) "\t_SanitizingName[39:51],", + (string) (len=24) "\t_SanitizingName[51:61],", + (string) (len=24) "\t_SanitizingName[61:72],", + (string) (len=24) "\t_SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// SanitizingNames returns a list of possible string values of Sanitizing.", + (string) (len=33) "func SanitizingNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_SanitizingNames))", + (string) (len=28) "\tcopy(tmp, _SanitizingNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=51) "\tSanitizingTestHyphen: _SanitizingName[0:11],", + (string) (len=52) "\tSanitizingHyphenStart: _SanitizingName[11:23],", + (string) (len=52) "\tSanitizing_UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=52) "\tSanitizing0NumberFirst: _SanitizingName[39:51],", + (string) (len=52) "\tSanitizing123456789A: _SanitizingName[51:61],", + (string) (len=52) "\tSanitizing123123Asdf: _SanitizingName[61:72],", + (string) (len=52) "\tSanitizingEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=63) "\t_SanitizingName[0:11]: SanitizingTestHyphen,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[0:11]): SanitizingTestHyphen,", + (string) (len=64) "\t_SanitizingName[11:23]: SanitizingHyphenStart,", + (string) (len=64) "\tstrings.ToLower(_SanitizingName[11:23]): SanitizingHyphenStart,", + (string) (len=69) "\t_SanitizingName[23:39]: Sanitizing_UnderscoreFirst,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[23:39]): Sanitizing_UnderscoreFirst,", + (string) (len=65) "\t_SanitizingName[39:51]: Sanitizing0NumberFirst,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[39:51]): Sanitizing0NumberFirst,", + (string) (len=63) "\t_SanitizingName[51:61]: Sanitizing123456789A,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[51:61]): Sanitizing123456789A,", + (string) (len=63) "\t_SanitizingName[61:72]: Sanitizing123123Asdf,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[61:72]): Sanitizing123123Asdf,", + (string) (len=65) "\t_SanitizingName[72:86]: SanitizingEndingHyphen,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[72:86]): SanitizingEndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _SanitizingValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errSanitizingNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = Sanitizing(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseSanitizing(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseSanitizing(string(v))", + (string) (len=17) "\tcase Sanitizing:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\tcase *Sanitizing:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x Sanitizing) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=36) "\t// SodaCoke is a Soda of type Coke.", + (string) (len=21) "\tSodaCoke Soda = iota", + (string) (len=38) "\t// SodaPepsi is a Soda of type Pepsi.", + (string) (len=10) "\tSodaPepsi", + (string) (len=40) "\t// SodaMtnDew is a Soda of type MtnDew.", + (string) (len=11) "\tSodaMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=93) "var ErrInvalidSoda = fmt.Errorf(\"not a valid Soda, try [%s]\", strings.Join(_SodaNames, \", \"))", + (string) "", + (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", + (string) "", + (string) (len=26) "var _SodaNames = []string{", + (string) (len=16) "\t_SodaName[0:4],", + (string) (len=16) "\t_SodaName[4:9],", + (string) (len=17) "\t_SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// SodaNames returns a list of possible string values of Soda.", + (string) (len=27) "func SodaNames() []string {", + (string) (len=39) "\ttmp := make([]string, len(_SodaNames))", + (string) (len=22) "\tcopy(tmp, _SodaNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=28) "\tSodaCoke: _SodaName[0:4],", + (string) (len=28) "\tSodaPepsi: _SodaName[4:9],", + (string) (len=29) "\tSodaMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=44) "\t_SodaName[0:4]: SodaCoke,", + (string) (len=44) "\tstrings.ToLower(_SodaName[0:4]): SodaCoke,", + (string) (len=45) "\t_SodaName[4:9]: SodaPepsi,", + (string) (len=45) "\tstrings.ToLower(_SodaName[4:9]): SodaPepsi,", + (string) (len=46) "\t_SodaName[9:15]: SodaMtnDew,", + (string) (len=46) "\tstrings.ToLower(_SodaName[9:15]): SodaMtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=52) "\tif x, ok := _SodaValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=90) "var errSodaNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=52) "func (x *Soda) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=14) "\t\t*x = Soda(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase string:", + (string) (len=24) "\t\t*x, err = ParseSoda(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=32) "\t\t*x, err = ParseSoda(string(v))", + (string) (len=11) "\tcase Soda:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=12) "\tcase *Soda:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=25) "\t\t*x, err = ParseSoda(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=45) "func (x Soda) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=68) "\t// StartNotZeroStartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=50) "\tStartNotZeroStartWithNum StartNotZero = iota + 23", + (string) (len=58) "\t// StartNotZeroNextNum is a StartNotZero of type NextNum.", + (string) (len=20) "\tStartNotZeroNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=117) "var ErrInvalidStartNotZero = fmt.Errorf(\"not a valid StartNotZero, try [%s]\", strings.Join(_StartNotZeroNames, \", \"))", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", + (string) "", + (string) (len=34) "var _StartNotZeroNames = []string{", + (string) (len=25) "\t_StartNotZeroName[0:12],", + (string) (len=26) "\t_StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// StartNotZeroNames returns a list of possible string values of StartNotZero.", + (string) (len=35) "func StartNotZeroNames() []string {", + (string) (len=47) "\ttmp := make([]string, len(_StartNotZeroNames))", + (string) (len=30) "\tcopy(tmp, _StartNotZeroNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=51) "\tStartNotZeroStartWithNum: _StartNotZeroName[0:12],", + (string) (len=52) "\tStartNotZeroNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=69) "\t_StartNotZeroName[0:12]: StartNotZeroStartWithNum,", + (string) (len=69) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartNotZeroStartWithNum,", + (string) (len=64) "\t_StartNotZeroName[12:19]: StartNotZeroNextNum,", + (string) (len=64) "\tstrings.ToLower(_StartNotZeroName[12:19]): StartNotZeroNextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=60) "\tif x, ok := _StartNotZeroValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=98) "var errStartNotZeroNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=60) "func (x *StartNotZero) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=22) "\t\t*x = StartNotZero(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase string:", + (string) (len=32) "\t\t*x, err = ParseStartNotZero(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=40) "\t\t*x, err = ParseStartNotZero(string(v))", + (string) (len=19) "\tcase StartNotZero:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=20) "\tcase *StartNotZero:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=33) "\t\t*x, err = ParseStartNotZero(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x StartNotZero) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// StringEnumRandom is a StringEnum of type random.", + (string) (len=39) "\tStringEnumRandom StringEnum = \"random\"", + (string) (len=52) "\t// StringEnumValues is a StringEnum of type values.", + (string) (len=39) "\tStringEnumValues StringEnum = \"values\"", + (string) (len=48) "\t// StringEnumHere is a StringEnum of type here.", + (string) (len=35) "\tStringEnumHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidStringEnum = fmt.Errorf(\"not a valid StringEnum, try [%s]\", strings.Join(_StringEnumNames, \", \"))", + (string) "", + (string) (len=32) "var _StringEnumNames = []string{", + (string) (len=26) "\tstring(StringEnumRandom),", + (string) (len=26) "\tstring(StringEnumValues),", + (string) (len=24) "\tstring(StringEnumHere),", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// StringEnumNames returns a list of possible string values of StringEnum.", + (string) (len=33) "func StringEnumNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_StringEnumNames))", + (string) (len=28) "\tcopy(tmp, _StringEnumNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=28) "\t\"random\": StringEnumRandom,", + (string) (len=28) "\t\"values\": StringEnumValues,", + (string) (len=26) "\t\"here\": StringEnumHere,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _StringEnumValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errStringEnumNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/TestExampleFileMoreOptions b/generator/.snapshots/TestExampleFileMoreOptions new file mode 100644 index 00000000..598607dc --- /dev/null +++ b/generator/.snapshots/TestExampleFileMoreOptions @@ -0,0 +1,2660 @@ +([]string) (len=2658) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=38) "\t// AnimalCat is a Animal of type Cat.", + (string) (len=24) "\tAnimalCat Animal = iota", + (string) (len=38) "\t// AnimalDog is a Animal of type Dog.", + (string) (len=10) "\tAnimalDog", + (string) (len=40) "\t// AnimalFish is a Animal of type Fish.", + (string) (len=11) "\tAnimalFish", + (string) (len=1) ")", + (string) "", + (string) (len=99) "var ErrInvalidAnimal = fmt.Errorf(\"not a valid Animal, try [%s]\", strings.Join(_AnimalNames, \", \"))", + (string) "", + (string) (len=32) "const _AnimalName = \"catdogfish\"", + (string) "", + (string) (len=28) "var _AnimalNames = []string{", + (string) (len=18) "\t_AnimalName[0:3],", + (string) (len=18) "\t_AnimalName[3:6],", + (string) (len=19) "\t_AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// AnimalNames returns a list of possible string values of Animal.", + (string) (len=29) "func AnimalNames() []string {", + (string) (len=41) "\ttmp := make([]string, len(_AnimalNames))", + (string) (len=24) "\tcopy(tmp, _AnimalNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=30) "\tAnimalCat: _AnimalName[0:3],", + (string) (len=30) "\tAnimalDog: _AnimalName[3:6],", + (string) (len=31) "\tAnimalFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=47) "\t_AnimalName[0:3]: AnimalCat,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[0:3]): AnimalCat,", + (string) (len=47) "\t_AnimalName[3:6]: AnimalDog,", + (string) (len=47) "\tstrings.ToLower(_AnimalName[3:6]): AnimalDog,", + (string) (len=48) "\t_AnimalName[6:10]: AnimalFish,", + (string) (len=48) "\tstrings.ToLower(_AnimalName[6:10]): AnimalFish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=54) "\tif x, ok := _AnimalValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=77) "// MustParseAnimal converts a string to a Animal, and panics if is not valid.", + (string) (len=42) "func MustParseAnimal(name string) Animal {", + (string) (len=30) "\tval, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=92) "var errAnimalNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=54) "func (x *Animal) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=16) "\t\t*x = Animal(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase string:", + (string) (len=26) "\t\t*x, err = ParseAnimal(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=34) "\t\t*x, err = ParseAnimal(string(v))", + (string) (len=13) "\tcase Animal:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=14) "\tcase *Animal:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x, err = ParseAnimal(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=47) "func (x Animal) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=32) "func ParseAnimalExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=38) "func ParseAnimalDescription() string {", + (string) (len=18) "\treturn `Animal x`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=50) "\t// CasesTest_lower is a Cases of type Test_lower.", + (string) (len=29) "\tCasesTest_lower Cases = iota", + (string) (len=54) "\t// CasesTest_capital is a Cases of type Test_capital.", + (string) (len=18) "\tCasesTest_capital", + (string) (len=72) "\t// CasesAnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=27) "\tCasesAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidCases = fmt.Errorf(\"not a valid Cases, try [%s]\", strings.Join(_CasesNames, \", \"))", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowertest_capitalanotherlowercasestart\"", + (string) "", + (string) (len=27) "var _CasesNames = []string{", + (string) (len=18) "\t_CasesName[0:10],", + (string) (len=19) "\t_CasesName[10:22],", + (string) (len=19) "\t_CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// CasesNames returns a list of possible string values of Cases.", + (string) (len=28) "func CasesNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_CasesNames))", + (string) (len=23) "\tcopy(tmp, _CasesNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=46) "\tCasesTest_lower: _CasesName[0:10],", + (string) (len=47) "\tCasesTest_capital: _CasesName[10:22],", + (string) (len=47) "\tCasesAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=53) "\t_CasesName[0:10]: CasesTest_lower,", + (string) (len=53) "\tstrings.ToLower(_CasesName[0:10]): CasesTest_lower,", + (string) (len=55) "\t_CasesName[10:22]: CasesTest_capital,", + (string) (len=55) "\tstrings.ToLower(_CasesName[10:22]): CasesTest_capital,", + (string) (len=64) "\t_CasesName[22:43]: CasesAnotherLowerCaseStart,", + (string) (len=64) "\tstrings.ToLower(_CasesName[22:43]): CasesAnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _CasesValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseCases converts a string to a Cases, and panics if is not valid.", + (string) (len=40) "func MustParseCases(name string) Cases {", + (string) (len=29) "\tval, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errCasesNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Cases) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Cases(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseCases(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseCases(string(v))", + (string) (len=12) "\tcase Cases:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase *Cases:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseCases(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Cases) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseCasesExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseCasesDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=40) "\t// ColorBlack is a Color of type Black.", + (string) (len=24) "\tColorBlack Color = iota", + (string) (len=40) "\t// ColorWhite is a Color of type White.", + (string) (len=11) "\tColorWhite", + (string) (len=36) "\t// ColorRed is a Color of type Red.", + (string) (len=9) "\tColorRed", + (string) (len=40) "\t// ColorGreen is a Color of type Green.", + (string) (len=11) "\tColorGreen", + (string) (len=38) "\t// ColorBlue is a Color of type Blue.", + (string) (len=28) "\tColorBlue Color = iota + 29", + (string) (len=38) "\t// ColorGrey is a Color of type Grey.", + (string) (len=10) "\tColorGrey", + (string) (len=42) "\t// ColorYellow is a Color of type Yellow.", + (string) (len=12) "\tColorYellow", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidColor = fmt.Errorf(\"not a valid Color, try [%s]\", strings.Join(_ColorNames, \", \"))", + (string) "", + (string) (len=53) "const _ColorName = \"blackwhiteredgreenbluegreyyellow\"", + (string) "", + (string) (len=27) "var _ColorNames = []string{", + (string) (len=17) "\t_ColorName[0:5],", + (string) (len=18) "\t_ColorName[5:10],", + (string) (len=19) "\t_ColorName[10:13],", + (string) (len=19) "\t_ColorName[13:18],", + (string) (len=19) "\t_ColorName[18:22],", + (string) (len=19) "\t_ColorName[22:26],", + (string) (len=19) "\t_ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ColorNames returns a list of possible string values of Color.", + (string) (len=28) "func ColorNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ColorNames))", + (string) (len=23) "\tcopy(tmp, _ColorNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=30) "\tColorBlack: _ColorName[0:5],", + (string) (len=31) "\tColorWhite: _ColorName[5:10],", + (string) (len=32) "\tColorRed: _ColorName[10:13],", + (string) (len=32) "\tColorGreen: _ColorName[13:18],", + (string) (len=32) "\tColorBlue: _ColorName[18:22],", + (string) (len=32) "\tColorGrey: _ColorName[22:26],", + (string) (len=32) "\tColorYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=48) "\t_ColorName[0:5]: ColorBlack,", + (string) (len=48) "\tstrings.ToLower(_ColorName[0:5]): ColorBlack,", + (string) (len=48) "\t_ColorName[5:10]: ColorWhite,", + (string) (len=48) "\tstrings.ToLower(_ColorName[5:10]): ColorWhite,", + (string) (len=46) "\t_ColorName[10:13]: ColorRed,", + (string) (len=46) "\tstrings.ToLower(_ColorName[10:13]): ColorRed,", + (string) (len=48) "\t_ColorName[13:18]: ColorGreen,", + (string) (len=48) "\tstrings.ToLower(_ColorName[13:18]): ColorGreen,", + (string) (len=47) "\t_ColorName[18:22]: ColorBlue,", + (string) (len=47) "\tstrings.ToLower(_ColorName[18:22]): ColorBlue,", + (string) (len=47) "\t_ColorName[22:26]: ColorGrey,", + (string) (len=47) "\tstrings.ToLower(_ColorName[22:26]): ColorGrey,", + (string) (len=49) "\t_ColorName[26:32]: ColorYellow,", + (string) (len=49) "\tstrings.ToLower(_ColorName[26:32]): ColorYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _ColorValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseColor converts a string to a Color, and panics if is not valid.", + (string) (len=40) "func MustParseColor(name string) Color {", + (string) (len=29) "\tval, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errColorNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Color) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Color(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseColor(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseColor(string(v))", + (string) (len=12) "\tcase Color:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase *Color:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseColor(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Color) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseColorExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseColorDescription() string {", + (string) (len=61) "\treturn `Color is an enumeration of colors that are allowed.`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=62) "\t// ColorWithCommentBlack is a ColorWithComment of type Black.", + (string) (len=46) "\tColorWithCommentBlack ColorWithComment = iota", + (string) (len=62) "\t// ColorWithCommentWhite is a ColorWithComment of type White.", + (string) (len=22) "\tColorWithCommentWhite", + (string) (len=58) "\t// ColorWithCommentRed is a ColorWithComment of type Red.", + (string) (len=20) "\tColorWithCommentRed", + (string) (len=62) "\t// ColorWithCommentGreen is a ColorWithComment of type Green.", + (string) (len=22) "\tColorWithCommentGreen", + (string) (len=60) "\t// ColorWithCommentBlue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=50) "\tColorWithCommentBlue ColorWithComment = iota + 29", + (string) (len=60) "\t// ColorWithCommentGrey is a ColorWithComment of type Grey.", + (string) (len=21) "\tColorWithCommentGrey", + (string) (len=64) "\t// ColorWithCommentYellow is a ColorWithComment of type Yellow.", + (string) (len=23) "\tColorWithCommentYellow", + (string) (len=1) ")", + (string) "", + (string) (len=129) "var ErrInvalidColorWithComment = fmt.Errorf(\"not a valid ColorWithComment, try [%s]\", strings.Join(_ColorWithCommentNames, \", \"))", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"blackwhiteredgreenbluegreyyellow\"", + (string) "", + (string) (len=38) "var _ColorWithCommentNames = []string{", + (string) (len=28) "\t_ColorWithCommentName[0:5],", + (string) (len=29) "\t_ColorWithCommentName[5:10],", + (string) (len=30) "\t_ColorWithCommentName[10:13],", + (string) (len=30) "\t_ColorWithCommentName[13:18],", + (string) (len=30) "\t_ColorWithCommentName[18:22],", + (string) (len=30) "\t_ColorWithCommentName[22:26],", + (string) (len=30) "\t_ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=86) "// ColorWithCommentNames returns a list of possible string values of ColorWithComment.", + (string) (len=39) "func ColorWithCommentNames() []string {", + (string) (len=51) "\ttmp := make([]string, len(_ColorWithCommentNames))", + (string) (len=34) "\tcopy(tmp, _ColorWithCommentNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=52) "\tColorWithCommentBlack: _ColorWithCommentName[0:5],", + (string) (len=53) "\tColorWithCommentWhite: _ColorWithCommentName[5:10],", + (string) (len=54) "\tColorWithCommentRed: _ColorWithCommentName[10:13],", + (string) (len=54) "\tColorWithCommentGreen: _ColorWithCommentName[13:18],", + (string) (len=54) "\tColorWithCommentBlue: _ColorWithCommentName[18:22],", + (string) (len=54) "\tColorWithCommentGrey: _ColorWithCommentName[22:26],", + (string) (len=54) "\tColorWithCommentYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=70) "\t_ColorWithCommentName[0:5]: ColorWithCommentBlack,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[0:5]): ColorWithCommentBlack,", + (string) (len=70) "\t_ColorWithCommentName[5:10]: ColorWithCommentWhite,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[5:10]): ColorWithCommentWhite,", + (string) (len=68) "\t_ColorWithCommentName[10:13]: ColorWithCommentRed,", + (string) (len=68) "\tstrings.ToLower(_ColorWithCommentName[10:13]): ColorWithCommentRed,", + (string) (len=70) "\t_ColorWithCommentName[13:18]: ColorWithCommentGreen,", + (string) (len=70) "\tstrings.ToLower(_ColorWithCommentName[13:18]): ColorWithCommentGreen,", + (string) (len=69) "\t_ColorWithCommentName[18:22]: ColorWithCommentBlue,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[18:22]): ColorWithCommentBlue,", + (string) (len=69) "\t_ColorWithCommentName[22:26]: ColorWithCommentGrey,", + (string) (len=69) "\tstrings.ToLower(_ColorWithCommentName[22:26]): ColorWithCommentGrey,", + (string) (len=71) "\t_ColorWithCommentName[26:32]: ColorWithCommentYellow,", + (string) (len=71) "\tstrings.ToLower(_ColorWithCommentName[26:32]): ColorWithCommentYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=64) "\tif x, ok := _ColorWithCommentValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=97) "// MustParseColorWithComment converts a string to a ColorWithComment, and panics if is not valid.", + (string) (len=62) "func MustParseColorWithComment(name string) ColorWithComment {", + (string) (len=40) "\tval, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=102) "var errColorWithCommentNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=64) "func (x *ColorWithComment) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=26) "\t\t*x = ColorWithComment(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase string:", + (string) (len=36) "\t\t*x, err = ParseColorWithComment(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=44) "\t\t*x, err = ParseColorWithComment(string(v))", + (string) (len=23) "\tcase ColorWithComment:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=24) "\tcase *ColorWithComment:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=37) "\t\t*x, err = ParseColorWithComment(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x ColorWithComment) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=42) "func ParseColorWithCommentExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=48) "func ParseColorWithCommentDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment2Black is a ColorWithComment2 of type Black.", + (string) (len=48) "\tColorWithComment2Black ColorWithComment2 = iota", + (string) (len=64) "\t// ColorWithComment2White is a ColorWithComment2 of type White.", + (string) (len=23) "\tColorWithComment2White", + (string) (len=60) "\t// ColorWithComment2Red is a ColorWithComment2 of type Red.", + (string) (len=21) "\tColorWithComment2Red", + (string) (len=64) "\t// ColorWithComment2Green is a ColorWithComment2 of type Green.", + (string) (len=23) "\tColorWithComment2Green", + (string) (len=62) "\t// ColorWithComment2Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=52) "\tColorWithComment2Blue ColorWithComment2 = iota + 29", + (string) (len=62) "\t// ColorWithComment2Grey is a ColorWithComment2 of type Grey.", + (string) (len=22) "\tColorWithComment2Grey", + (string) (len=66) "\t// ColorWithComment2Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=24) "\tColorWithComment2Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment2 = fmt.Errorf(\"not a valid ColorWithComment2, try [%s]\", strings.Join(_ColorWithComment2Names, \", \"))", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"blackwhiteredgreenbluegreyyellow\"", + (string) "", + (string) (len=39) "var _ColorWithComment2Names = []string{", + (string) (len=29) "\t_ColorWithComment2Name[0:5],", + (string) (len=30) "\t_ColorWithComment2Name[5:10],", + (string) (len=31) "\t_ColorWithComment2Name[10:13],", + (string) (len=31) "\t_ColorWithComment2Name[13:18],", + (string) (len=31) "\t_ColorWithComment2Name[18:22],", + (string) (len=31) "\t_ColorWithComment2Name[22:26],", + (string) (len=31) "\t_ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment2Names returns a list of possible string values of ColorWithComment2.", + (string) (len=40) "func ColorWithComment2Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment2Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment2Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=54) "\tColorWithComment2Black: _ColorWithComment2Name[0:5],", + (string) (len=55) "\tColorWithComment2White: _ColorWithComment2Name[5:10],", + (string) (len=56) "\tColorWithComment2Red: _ColorWithComment2Name[10:13],", + (string) (len=56) "\tColorWithComment2Green: _ColorWithComment2Name[13:18],", + (string) (len=56) "\tColorWithComment2Blue: _ColorWithComment2Name[18:22],", + (string) (len=56) "\tColorWithComment2Grey: _ColorWithComment2Name[22:26],", + (string) (len=56) "\tColorWithComment2Yellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=72) "\t_ColorWithComment2Name[0:5]: ColorWithComment2Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): ColorWithComment2Black,", + (string) (len=72) "\t_ColorWithComment2Name[5:10]: ColorWithComment2White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): ColorWithComment2White,", + (string) (len=70) "\t_ColorWithComment2Name[10:13]: ColorWithComment2Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): ColorWithComment2Red,", + (string) (len=72) "\t_ColorWithComment2Name[13:18]: ColorWithComment2Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): ColorWithComment2Green,", + (string) (len=71) "\t_ColorWithComment2Name[18:22]: ColorWithComment2Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): ColorWithComment2Blue,", + (string) (len=71) "\t_ColorWithComment2Name[22:26]: ColorWithComment2Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): ColorWithComment2Grey,", + (string) (len=73) "\t_ColorWithComment2Name[26:32]: ColorWithComment2Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): ColorWithComment2Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment2Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment2 converts a string to a ColorWithComment2, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment2(name string) ColorWithComment2 {", + (string) (len=41) "\tval, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment2NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment2) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment2(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment2(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment2(string(v))", + (string) (len=24) "\tcase ColorWithComment2:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=25) "\tcase *ColorWithComment2:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment2(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment2) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment2Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment2Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment3Black is a ColorWithComment3 of type Black.", + (string) (len=48) "\tColorWithComment3Black ColorWithComment3 = iota", + (string) (len=64) "\t// ColorWithComment3White is a ColorWithComment3 of type White.", + (string) (len=23) "\tColorWithComment3White", + (string) (len=60) "\t// ColorWithComment3Red is a ColorWithComment3 of type Red.", + (string) (len=21) "\tColorWithComment3Red", + (string) (len=64) "\t// ColorWithComment3Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment3Green ColorWithComment3 = iota + 30", + (string) (len=62) "\t// ColorWithComment3Blue is a ColorWithComment3 of type Blue.", + (string) (len=22) "\tColorWithComment3Blue", + (string) (len=62) "\t// ColorWithComment3Grey is a ColorWithComment3 of type Grey.", + (string) (len=22) "\tColorWithComment3Grey", + (string) (len=66) "\t// ColorWithComment3Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=24) "\tColorWithComment3Yellow", + (string) (len=73) "\t// ColorWithComment3BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment3BlueGreen", + (string) (len=73) "\t// ColorWithComment3RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=27) "\tColorWithComment3RedOrange", + (string) (len=82) "\t// ColorWithComment3RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=31) "\tColorWithComment3RedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment3 = fmt.Errorf(\"not a valid ColorWithComment3, try [%s]\", strings.Join(_ColorWithComment3Names, \", \"))", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"blackwhiteredgreenbluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=39) "var _ColorWithComment3Names = []string{", + (string) (len=29) "\t_ColorWithComment3Name[0:5],", + (string) (len=30) "\t_ColorWithComment3Name[5:10],", + (string) (len=31) "\t_ColorWithComment3Name[10:13],", + (string) (len=31) "\t_ColorWithComment3Name[13:18],", + (string) (len=31) "\t_ColorWithComment3Name[18:22],", + (string) (len=31) "\t_ColorWithComment3Name[22:26],", + (string) (len=31) "\t_ColorWithComment3Name[26:32],", + (string) (len=31) "\t_ColorWithComment3Name[32:42],", + (string) (len=31) "\t_ColorWithComment3Name[42:52],", + (string) (len=31) "\t_ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment3Names returns a list of possible string values of ColorWithComment3.", + (string) (len=40) "func ColorWithComment3Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment3Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment3Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=61) "\tColorWithComment3Black: _ColorWithComment3Name[0:5],", + (string) (len=62) "\tColorWithComment3White: _ColorWithComment3Name[5:10],", + (string) (len=63) "\tColorWithComment3Red: _ColorWithComment3Name[10:13],", + (string) (len=63) "\tColorWithComment3Green: _ColorWithComment3Name[13:18],", + (string) (len=63) "\tColorWithComment3Blue: _ColorWithComment3Name[18:22],", + (string) (len=63) "\tColorWithComment3Grey: _ColorWithComment3Name[22:26],", + (string) (len=63) "\tColorWithComment3Yellow: _ColorWithComment3Name[26:32],", + (string) (len=63) "\tColorWithComment3BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=63) "\tColorWithComment3RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=63) "\tColorWithComment3RedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=72) "\t_ColorWithComment3Name[0:5]: ColorWithComment3Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): ColorWithComment3Black,", + (string) (len=72) "\t_ColorWithComment3Name[5:10]: ColorWithComment3White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): ColorWithComment3White,", + (string) (len=70) "\t_ColorWithComment3Name[10:13]: ColorWithComment3Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): ColorWithComment3Red,", + (string) (len=72) "\t_ColorWithComment3Name[13:18]: ColorWithComment3Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): ColorWithComment3Green,", + (string) (len=71) "\t_ColorWithComment3Name[18:22]: ColorWithComment3Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): ColorWithComment3Blue,", + (string) (len=71) "\t_ColorWithComment3Name[22:26]: ColorWithComment3Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): ColorWithComment3Grey,", + (string) (len=73) "\t_ColorWithComment3Name[26:32]: ColorWithComment3Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): ColorWithComment3Yellow,", + (string) (len=76) "\t_ColorWithComment3Name[32:42]: ColorWithComment3BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): ColorWithComment3BlueGreen,", + (string) (len=76) "\t_ColorWithComment3Name[42:52]: ColorWithComment3RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): ColorWithComment3RedOrange,", + (string) (len=80) "\t_ColorWithComment3Name[52:67]: ColorWithComment3RedOrangeBlue,", + (string) (len=80) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): ColorWithComment3RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment3Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment3 converts a string to a ColorWithComment3, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment3(name string) ColorWithComment3 {", + (string) (len=41) "\tval, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment3NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment3) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment3(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment3(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment3(string(v))", + (string) (len=24) "\tcase ColorWithComment3:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=25) "\tcase *ColorWithComment3:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment3(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment3) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment3Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment3Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=64) "\t// ColorWithComment4Black is a ColorWithComment4 of type Black.", + (string) (len=23) "\tColorWithComment4Black", + (string) (len=64) "\t// ColorWithComment4White is a ColorWithComment4 of type White.", + (string) (len=23) "\tColorWithComment4White", + (string) (len=60) "\t// ColorWithComment4Red is a ColorWithComment4 of type Red.", + (string) (len=21) "\tColorWithComment4Red", + (string) (len=64) "\t// ColorWithComment4Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment4Green ColorWithComment4 = iota + 29", + (string) (len=62) "\t// ColorWithComment4Blue is a ColorWithComment4 of type Blue.", + (string) (len=22) "\tColorWithComment4Blue", + (string) (len=62) "\t// ColorWithComment4Grey is a ColorWithComment4 of type Grey.", + (string) (len=22) "\tColorWithComment4Grey", + (string) (len=66) "\t// ColorWithComment4Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=24) "\tColorWithComment4Yellow", + (string) (len=73) "\t// ColorWithComment4BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment4BlueGreen", + (string) (len=73) "\t// ColorWithComment4RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=27) "\tColorWithComment4RedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment4 = fmt.Errorf(\"not a valid ColorWithComment4, try [%s]\", strings.Join(_ColorWithComment4Names, \", \"))", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"blackwhiteredgreenbluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=39) "var _ColorWithComment4Names = []string{", + (string) (len=29) "\t_ColorWithComment4Name[0:5],", + (string) (len=30) "\t_ColorWithComment4Name[5:10],", + (string) (len=31) "\t_ColorWithComment4Name[10:13],", + (string) (len=31) "\t_ColorWithComment4Name[13:18],", + (string) (len=31) "\t_ColorWithComment4Name[18:22],", + (string) (len=31) "\t_ColorWithComment4Name[22:26],", + (string) (len=31) "\t_ColorWithComment4Name[26:32],", + (string) (len=31) "\t_ColorWithComment4Name[32:42],", + (string) (len=31) "\t_ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment4Names returns a list of possible string values of ColorWithComment4.", + (string) (len=40) "func ColorWithComment4Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment4Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment4Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=57) "\tColorWithComment4Black: _ColorWithComment4Name[0:5],", + (string) (len=58) "\tColorWithComment4White: _ColorWithComment4Name[5:10],", + (string) (len=59) "\tColorWithComment4Red: _ColorWithComment4Name[10:13],", + (string) (len=59) "\tColorWithComment4Green: _ColorWithComment4Name[13:18],", + (string) (len=59) "\tColorWithComment4Blue: _ColorWithComment4Name[18:22],", + (string) (len=59) "\tColorWithComment4Grey: _ColorWithComment4Name[22:26],", + (string) (len=59) "\tColorWithComment4Yellow: _ColorWithComment4Name[26:32],", + (string) (len=59) "\tColorWithComment4BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=59) "\tColorWithComment4RedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=72) "\t_ColorWithComment4Name[0:5]: ColorWithComment4Black,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): ColorWithComment4Black,", + (string) (len=72) "\t_ColorWithComment4Name[5:10]: ColorWithComment4White,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): ColorWithComment4White,", + (string) (len=70) "\t_ColorWithComment4Name[10:13]: ColorWithComment4Red,", + (string) (len=70) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): ColorWithComment4Red,", + (string) (len=72) "\t_ColorWithComment4Name[13:18]: ColorWithComment4Green,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): ColorWithComment4Green,", + (string) (len=71) "\t_ColorWithComment4Name[18:22]: ColorWithComment4Blue,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): ColorWithComment4Blue,", + (string) (len=71) "\t_ColorWithComment4Name[22:26]: ColorWithComment4Grey,", + (string) (len=71) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): ColorWithComment4Grey,", + (string) (len=73) "\t_ColorWithComment4Name[26:32]: ColorWithComment4Yellow,", + (string) (len=73) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): ColorWithComment4Yellow,", + (string) (len=76) "\t_ColorWithComment4Name[32:42]: ColorWithComment4BlueGreen,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): ColorWithComment4BlueGreen,", + (string) (len=76) "\t_ColorWithComment4Name[42:52]: ColorWithComment4RedOrange,", + (string) (len=76) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): ColorWithComment4RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=65) "\tif x, ok := _ColorWithComment4Value[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment4 converts a string to a ColorWithComment4, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment4(name string) ColorWithComment4 {", + (string) (len=41) "\tval, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment4NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment4) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment4(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment4(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment4(string(v))", + (string) (len=24) "\tcase ColorWithComment4:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=25) "\tcase *ColorWithComment4:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment4(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment4) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment4Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment4Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Enum64bitUnknown is a Enum64bit of type Unknown.", + (string) (len=34) "\tEnum64bitUnknown Enum64bit = iota", + (string) (len=48) "\t// Enum64bitE2P15 is a Enum64bit of type E2P15.", + (string) (len=40) "\tEnum64bitE2P15 Enum64bit = iota + 32767", + (string) (len=48) "\t// Enum64bitE2P16 is a Enum64bit of type E2P16.", + (string) (len=40) "\tEnum64bitE2P16 Enum64bit = iota + 65534", + (string) (len=48) "\t// Enum64bitE2P17 is a Enum64bit of type E2P17.", + (string) (len=41) "\tEnum64bitE2P17 Enum64bit = iota + 131069", + (string) (len=48) "\t// Enum64bitE2P18 is a Enum64bit of type E2P18.", + (string) (len=41) "\tEnum64bitE2P18 Enum64bit = iota + 262140", + (string) (len=48) "\t// Enum64bitE2P19 is a Enum64bit of type E2P19.", + (string) (len=41) "\tEnum64bitE2P19 Enum64bit = iota + 524283", + (string) (len=48) "\t// Enum64bitE2P20 is a Enum64bit of type E2P20.", + (string) (len=42) "\tEnum64bitE2P20 Enum64bit = iota + 1048570", + (string) (len=48) "\t// Enum64bitE2P21 is a Enum64bit of type E2P21.", + (string) (len=42) "\tEnum64bitE2P21 Enum64bit = iota + 2097145", + (string) (len=48) "\t// Enum64bitE2P22 is a Enum64bit of type E2P22.", + (string) (len=43) "\tEnum64bitE2P22 Enum64bit = iota + 33554424", + (string) (len=48) "\t// Enum64bitE2P23 is a Enum64bit of type E2P23.", + (string) (len=43) "\tEnum64bitE2P23 Enum64bit = iota + 67108855", + (string) (len=48) "\t// Enum64bitE2P28 is a Enum64bit of type E2P28.", + (string) (len=44) "\tEnum64bitE2P28 Enum64bit = iota + 536870902", + (string) (len=48) "\t// Enum64bitE2P30 is a Enum64bit of type E2P30.", + (string) (len=45) "\tEnum64bitE2P30 Enum64bit = iota + 1073741813", + (string) (len=48) "\t// Enum64bitE2P31 is a Enum64bit of type E2P31.", + (string) (len=45) "\tEnum64bitE2P31 Enum64bit = iota + 2147483636", + (string) (len=48) "\t// Enum64bitE2P32 is a Enum64bit of type E2P32.", + (string) (len=45) "\tEnum64bitE2P32 Enum64bit = iota + 4294967283", + (string) (len=48) "\t// Enum64bitE2P33 is a Enum64bit of type E2P33.", + (string) (len=45) "\tEnum64bitE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=108) "var ErrInvalidEnum64bit = fmt.Errorf(\"not a valid Enum64bit, try [%s]\", strings.Join(_Enum64bitNames, \", \"))", + (string) "", + (string) (len=102) "const _Enum64bitName = \"unknowne2p15e2p16e2p17e2p18e2p19e2p20e2p21e2p22e2p23e2p28e2p30e2p31e2p32e2p33\"", + (string) "", + (string) (len=31) "var _Enum64bitNames = []string{", + (string) (len=21) "\t_Enum64bitName[0:7],", + (string) (len=22) "\t_Enum64bitName[7:12],", + (string) (len=23) "\t_Enum64bitName[12:17],", + (string) (len=23) "\t_Enum64bitName[17:22],", + (string) (len=23) "\t_Enum64bitName[22:27],", + (string) (len=23) "\t_Enum64bitName[27:32],", + (string) (len=23) "\t_Enum64bitName[32:37],", + (string) (len=23) "\t_Enum64bitName[37:42],", + (string) (len=23) "\t_Enum64bitName[42:47],", + (string) (len=23) "\t_Enum64bitName[47:52],", + (string) (len=23) "\t_Enum64bitName[52:57],", + (string) (len=23) "\t_Enum64bitName[57:62],", + (string) (len=23) "\t_Enum64bitName[62:67],", + (string) (len=23) "\t_Enum64bitName[67:72],", + (string) (len=23) "\t_Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=72) "// Enum64bitNames returns a list of possible string values of Enum64bit.", + (string) (len=32) "func Enum64bitNames() []string {", + (string) (len=44) "\ttmp := make([]string, len(_Enum64bitNames))", + (string) (len=27) "\tcopy(tmp, _Enum64bitNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=39) "\tEnum64bitUnknown: _Enum64bitName[0:7],", + (string) (len=40) "\tEnum64bitE2P15: _Enum64bitName[7:12],", + (string) (len=41) "\tEnum64bitE2P16: _Enum64bitName[12:17],", + (string) (len=41) "\tEnum64bitE2P17: _Enum64bitName[17:22],", + (string) (len=41) "\tEnum64bitE2P18: _Enum64bitName[22:27],", + (string) (len=41) "\tEnum64bitE2P19: _Enum64bitName[27:32],", + (string) (len=41) "\tEnum64bitE2P20: _Enum64bitName[32:37],", + (string) (len=41) "\tEnum64bitE2P21: _Enum64bitName[37:42],", + (string) (len=41) "\tEnum64bitE2P22: _Enum64bitName[42:47],", + (string) (len=41) "\tEnum64bitE2P23: _Enum64bitName[47:52],", + (string) (len=41) "\tEnum64bitE2P28: _Enum64bitName[52:57],", + (string) (len=41) "\tEnum64bitE2P30: _Enum64bitName[57:62],", + (string) (len=41) "\tEnum64bitE2P31: _Enum64bitName[62:67],", + (string) (len=41) "\tEnum64bitE2P32: _Enum64bitName[67:72],", + (string) (len=41) "\tEnum64bitE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=58) "\t_Enum64bitName[0:7]: Enum64bitUnknown,", + (string) (len=58) "\tstrings.ToLower(_Enum64bitName[0:7]): Enum64bitUnknown,", + (string) (len=56) "\t_Enum64bitName[7:12]: Enum64bitE2P15,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[7:12]): Enum64bitE2P15,", + (string) (len=56) "\t_Enum64bitName[12:17]: Enum64bitE2P16,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[12:17]): Enum64bitE2P16,", + (string) (len=56) "\t_Enum64bitName[17:22]: Enum64bitE2P17,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[17:22]): Enum64bitE2P17,", + (string) (len=56) "\t_Enum64bitName[22:27]: Enum64bitE2P18,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[22:27]): Enum64bitE2P18,", + (string) (len=56) "\t_Enum64bitName[27:32]: Enum64bitE2P19,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[27:32]): Enum64bitE2P19,", + (string) (len=56) "\t_Enum64bitName[32:37]: Enum64bitE2P20,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[32:37]): Enum64bitE2P20,", + (string) (len=56) "\t_Enum64bitName[37:42]: Enum64bitE2P21,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[37:42]): Enum64bitE2P21,", + (string) (len=56) "\t_Enum64bitName[42:47]: Enum64bitE2P22,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[42:47]): Enum64bitE2P22,", + (string) (len=56) "\t_Enum64bitName[47:52]: Enum64bitE2P23,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[47:52]): Enum64bitE2P23,", + (string) (len=56) "\t_Enum64bitName[52:57]: Enum64bitE2P28,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[52:57]): Enum64bitE2P28,", + (string) (len=56) "\t_Enum64bitName[57:62]: Enum64bitE2P30,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[57:62]): Enum64bitE2P30,", + (string) (len=56) "\t_Enum64bitName[62:67]: Enum64bitE2P31,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[62:67]): Enum64bitE2P31,", + (string) (len=56) "\t_Enum64bitName[67:72]: Enum64bitE2P32,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[67:72]): Enum64bitE2P32,", + (string) (len=56) "\t_Enum64bitName[72:77]: Enum64bitE2P33,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[72:77]): Enum64bitE2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=57) "\tif x, ok := _Enum64bitValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=83) "// MustParseEnum64bit converts a string to a Enum64bit, and panics if is not valid.", + (string) (len=48) "func MustParseEnum64bit(name string) Enum64bit {", + (string) (len=33) "\tval, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=95) "var errEnum64bitNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *Enum64bit) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=19) "\t\t*x = Enum64bit(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase string:", + (string) (len=29) "\t\t*x, err = ParseEnum64bit(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=37) "\t\t*x, err = ParseEnum64bit(string(v))", + (string) (len=16) "\tcase Enum64bit:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=17) "\tcase *Enum64bit:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=30) "\t\t*x, err = ParseEnum64bit(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x Enum64bit) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=35) "func ParseEnum64bitExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=41) "func ParseEnum64bitDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// ModelToyota is a Model of type Toyota.", + (string) (len=25) "\tModelToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=40) "\t// ModelChevy is a Model of type Chevy.", + (string) (len=11) "\tModelChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=38) "\t// ModelFord is a Model of type Ford.", + (string) (len=10) "\tModelFord", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidModel = fmt.Errorf(\"not a valid Model, try [%s]\", strings.Join(_ModelNames, \", \"))", + (string) "", + (string) (len=36) "const _ModelName = \"toyotachevyford\"", + (string) "", + (string) (len=27) "var _ModelNames = []string{", + (string) (len=17) "\t_ModelName[0:6],", + (string) (len=18) "\t_ModelName[6:11],", + (string) (len=19) "\t_ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ModelNames returns a list of possible string values of Model.", + (string) (len=28) "func ModelNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ModelNames))", + (string) (len=23) "\tcopy(tmp, _ModelNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=30) "\tModelToyota: _ModelName[0:6],", + (string) (len=31) "\tModelChevy: _ModelName[6:11],", + (string) (len=32) "\tModelFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=49) "\t_ModelName[0:6]: ModelToyota,", + (string) (len=49) "\tstrings.ToLower(_ModelName[0:6]): ModelToyota,", + (string) (len=48) "\t_ModelName[6:11]: ModelChevy,", + (string) (len=48) "\tstrings.ToLower(_ModelName[6:11]): ModelChevy,", + (string) (len=47) "\t_ModelName[11:15]: ModelFord,", + (string) (len=47) "\tstrings.ToLower(_ModelName[11:15]): ModelFord,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=53) "\tif x, ok := _ModelValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseModel converts a string to a Model, and panics if is not valid.", + (string) (len=40) "func MustParseModel(name string) Model {", + (string) (len=29) "\tval, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errModelNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Model) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Model(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseModel(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseModel(string(v))", + (string) (len=12) "\tcase Model:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase *Model:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseModel(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Model) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseModelExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseModelDescription() string {", + (string) (len=17) "\treturn `Model x`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=60) "\t// NonASCIIПродам is a NonASCII of type Продам.", + (string) (len=44) "\tNonASCIIПродам NonASCII = iota + 1114", + (string) (len=48) "\t// NonASCII車庫 is a NonASCII of type 車庫.", + (string) (len=37) "\tNonASCII車庫 NonASCII = iota + 299", + (string) (len=52) "\t// NonASCIIԷժան is a NonASCII of type Էժան.", + (string) (len=38) "\tNonASCIIԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=105) "var ErrInvalidNonASCII = fmt.Errorf(\"not a valid NonASCII, try [%s]\", strings.Join(_NonASCIINames, \", \"))", + (string) "", + (string) (len=50) "const _NonASCIIName = \"продам車庫էժան\"", + (string) "", + (string) (len=30) "var _NonASCIINames = []string{", + (string) (len=21) "\t_NonASCIIName[0:12],", + (string) (len=22) "\t_NonASCIIName[12:18],", + (string) (len=22) "\t_NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=70) "// NonASCIINames returns a list of possible string values of NonASCII.", + (string) (len=31) "func NonASCIINames() []string {", + (string) (len=43) "\ttmp := make([]string, len(_NonASCIINames))", + (string) (len=26) "\tcopy(tmp, _NonASCIINames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=43) "\tNonASCIIПродам: _NonASCIIName[0:12],", + (string) (len=42) "\tNonASCII車庫: _NonASCIIName[12:18],", + (string) (len=42) "\tNonASCIIԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=61) "\t_NonASCIIName[0:12]: NonASCIIПродам,", + (string) (len=61) "\tstrings.ToLower(_NonASCIIName[0:12]): NonASCIIПродам,", + (string) (len=55) "\t_NonASCIIName[12:18]: NonASCII車庫,", + (string) (len=55) "\tstrings.ToLower(_NonASCIIName[12:18]): NonASCII車庫,", + (string) (len=57) "\t_NonASCIIName[18:26]: NonASCIIԷժան,", + (string) (len=57) "\tstrings.ToLower(_NonASCIIName[18:26]): NonASCIIԷժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=56) "\tif x, ok := _NonASCIIValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=81) "// MustParseNonASCII converts a string to a NonASCII, and panics if is not valid.", + (string) (len=46) "func MustParseNonASCII(name string) NonASCII {", + (string) (len=32) "\tval, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=94) "var errNonASCIINilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=56) "func (x *NonASCII) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=18) "\t\t*x = NonASCII(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase string:", + (string) (len=28) "\t\t*x, err = ParseNonASCII(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=36) "\t\t*x, err = ParseNonASCII(string(v))", + (string) (len=15) "\tcase NonASCII:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=16) "\tcase *NonASCII:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=29) "\t\t*x, err = ParseNonASCII(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=49) "func (x NonASCII) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=34) "func ParseNonASCIIExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=40) "func ParseNonASCIIDescription() string {", + (string) (len=18) "\treturn `NonASCII`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=61) "\t// SanitizingTestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=39) "\tSanitizingTestHyphen Sanitizing = iota", + (string) (len=63) "\t// SanitizingHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=22) "\tSanitizingHyphenStart", + (string) (len=72) "\t// Sanitizing_UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=27) "\tSanitizing_UnderscoreFirst", + (string) (len=64) "\t// Sanitizing0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=23) "\tSanitizing0NumberFirst", + (string) (len=60) "\t// Sanitizing123456789A is a Sanitizing of type 123456789A.", + (string) (len=21) "\tSanitizing123456789A", + (string) (len=61) "\t// Sanitizing123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=21) "\tSanitizing123123Asdf", + (string) (len=66) "\t// SanitizingEndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=23) "\tSanitizingEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidSanitizing = fmt.Errorf(\"not a valid Sanitizing, try [%s]\", strings.Join(_SanitizingNames, \", \"))", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-hyphen-hyphenstart_underscorefirst0numberfirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=32) "var _SanitizingNames = []string{", + (string) (len=23) "\t_SanitizingName[0:11],", + (string) (len=24) "\t_SanitizingName[11:23],", + (string) (len=24) "\t_SanitizingName[23:39],", + (string) (len=24) "\t_SanitizingName[39:51],", + (string) (len=24) "\t_SanitizingName[51:61],", + (string) (len=24) "\t_SanitizingName[61:72],", + (string) (len=24) "\t_SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// SanitizingNames returns a list of possible string values of Sanitizing.", + (string) (len=33) "func SanitizingNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_SanitizingNames))", + (string) (len=28) "\tcopy(tmp, _SanitizingNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=51) "\tSanitizingTestHyphen: _SanitizingName[0:11],", + (string) (len=52) "\tSanitizingHyphenStart: _SanitizingName[11:23],", + (string) (len=52) "\tSanitizing_UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=52) "\tSanitizing0NumberFirst: _SanitizingName[39:51],", + (string) (len=52) "\tSanitizing123456789A: _SanitizingName[51:61],", + (string) (len=52) "\tSanitizing123123Asdf: _SanitizingName[61:72],", + (string) (len=52) "\tSanitizingEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=63) "\t_SanitizingName[0:11]: SanitizingTestHyphen,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[0:11]): SanitizingTestHyphen,", + (string) (len=64) "\t_SanitizingName[11:23]: SanitizingHyphenStart,", + (string) (len=64) "\tstrings.ToLower(_SanitizingName[11:23]): SanitizingHyphenStart,", + (string) (len=69) "\t_SanitizingName[23:39]: Sanitizing_UnderscoreFirst,", + (string) (len=69) "\tstrings.ToLower(_SanitizingName[23:39]): Sanitizing_UnderscoreFirst,", + (string) (len=65) "\t_SanitizingName[39:51]: Sanitizing0NumberFirst,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[39:51]): Sanitizing0NumberFirst,", + (string) (len=63) "\t_SanitizingName[51:61]: Sanitizing123456789A,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[51:61]): Sanitizing123456789A,", + (string) (len=63) "\t_SanitizingName[61:72]: Sanitizing123123Asdf,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[61:72]): Sanitizing123123Asdf,", + (string) (len=65) "\t_SanitizingName[72:86]: SanitizingEndingHyphen,", + (string) (len=65) "\tstrings.ToLower(_SanitizingName[72:86]): SanitizingEndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _SanitizingValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=85) "// MustParseSanitizing converts a string to a Sanitizing, and panics if is not valid.", + (string) (len=50) "func MustParseSanitizing(name string) Sanitizing {", + (string) (len=34) "\tval, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errSanitizingNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = Sanitizing(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseSanitizing(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseSanitizing(string(v))", + (string) (len=17) "\tcase Sanitizing:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\tcase *Sanitizing:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x Sanitizing) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=36) "func ParseSanitizingExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=42) "func ParseSanitizingDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=36) "\t// SodaCoke is a Soda of type Coke.", + (string) (len=21) "\tSodaCoke Soda = iota", + (string) (len=38) "\t// SodaPepsi is a Soda of type Pepsi.", + (string) (len=10) "\tSodaPepsi", + (string) (len=40) "\t// SodaMtnDew is a Soda of type MtnDew.", + (string) (len=11) "\tSodaMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=93) "var ErrInvalidSoda = fmt.Errorf(\"not a valid Soda, try [%s]\", strings.Join(_SodaNames, \", \"))", + (string) "", + (string) (len=35) "const _SodaName = \"cokepepsimtndew\"", + (string) "", + (string) (len=26) "var _SodaNames = []string{", + (string) (len=16) "\t_SodaName[0:4],", + (string) (len=16) "\t_SodaName[4:9],", + (string) (len=17) "\t_SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// SodaNames returns a list of possible string values of Soda.", + (string) (len=27) "func SodaNames() []string {", + (string) (len=39) "\ttmp := make([]string, len(_SodaNames))", + (string) (len=22) "\tcopy(tmp, _SodaNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=28) "\tSodaCoke: _SodaName[0:4],", + (string) (len=28) "\tSodaPepsi: _SodaName[4:9],", + (string) (len=29) "\tSodaMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=44) "\t_SodaName[0:4]: SodaCoke,", + (string) (len=44) "\tstrings.ToLower(_SodaName[0:4]): SodaCoke,", + (string) (len=45) "\t_SodaName[4:9]: SodaPepsi,", + (string) (len=45) "\tstrings.ToLower(_SodaName[4:9]): SodaPepsi,", + (string) (len=46) "\t_SodaName[9:15]: SodaMtnDew,", + (string) (len=46) "\tstrings.ToLower(_SodaName[9:15]): SodaMtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=52) "\tif x, ok := _SodaValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=73) "// MustParseSoda converts a string to a Soda, and panics if is not valid.", + (string) (len=38) "func MustParseSoda(name string) Soda {", + (string) (len=28) "\tval, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=90) "var errSodaNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=52) "func (x *Soda) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=14) "\t\t*x = Soda(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase string:", + (string) (len=24) "\t\t*x, err = ParseSoda(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=32) "\t\t*x, err = ParseSoda(string(v))", + (string) (len=11) "\tcase Soda:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=12) "\tcase *Soda:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=25) "\t\t*x, err = ParseSoda(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=45) "func (x Soda) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=30) "func ParseSodaExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=36) "func ParseSodaDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=68) "\t// StartNotZeroStartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=50) "\tStartNotZeroStartWithNum StartNotZero = iota + 23", + (string) (len=58) "\t// StartNotZeroNextNum is a StartNotZero of type NextNum.", + (string) (len=20) "\tStartNotZeroNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=117) "var ErrInvalidStartNotZero = fmt.Errorf(\"not a valid StartNotZero, try [%s]\", strings.Join(_StartNotZeroNames, \", \"))", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startwithnumnextnum\"", + (string) "", + (string) (len=34) "var _StartNotZeroNames = []string{", + (string) (len=25) "\t_StartNotZeroName[0:12],", + (string) (len=26) "\t_StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// StartNotZeroNames returns a list of possible string values of StartNotZero.", + (string) (len=35) "func StartNotZeroNames() []string {", + (string) (len=47) "\ttmp := make([]string, len(_StartNotZeroNames))", + (string) (len=30) "\tcopy(tmp, _StartNotZeroNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=51) "\tStartNotZeroStartWithNum: _StartNotZeroName[0:12],", + (string) (len=52) "\tStartNotZeroNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=69) "\t_StartNotZeroName[0:12]: StartNotZeroStartWithNum,", + (string) (len=69) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartNotZeroStartWithNum,", + (string) (len=64) "\t_StartNotZeroName[12:19]: StartNotZeroNextNum,", + (string) (len=64) "\tstrings.ToLower(_StartNotZeroName[12:19]): StartNotZeroNextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=60) "\tif x, ok := _StartNotZeroValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=89) "// MustParseStartNotZero converts a string to a StartNotZero, and panics if is not valid.", + (string) (len=54) "func MustParseStartNotZero(name string) StartNotZero {", + (string) (len=36) "\tval, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=98) "var errStartNotZeroNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=60) "func (x *StartNotZero) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=22) "\t\t*x = StartNotZero(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase string:", + (string) (len=32) "\t\t*x, err = ParseStartNotZero(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=40) "\t\t*x, err = ParseStartNotZero(string(v))", + (string) (len=19) "\tcase StartNotZero:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=20) "\tcase *StartNotZero:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=33) "\t\t*x, err = ParseStartNotZero(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x StartNotZero) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=38) "func ParseStartNotZeroExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=44) "func ParseStartNotZeroDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// StringEnumRandom is a StringEnum of type random.", + (string) (len=39) "\tStringEnumRandom StringEnum = \"random\"", + (string) (len=52) "\t// StringEnumValues is a StringEnum of type values.", + (string) (len=39) "\tStringEnumValues StringEnum = \"values\"", + (string) (len=48) "\t// StringEnumHere is a StringEnum of type here.", + (string) (len=35) "\tStringEnumHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidStringEnum = fmt.Errorf(\"not a valid StringEnum, try [%s]\", strings.Join(_StringEnumNames, \", \"))", + (string) "", + (string) (len=32) "var _StringEnumNames = []string{", + (string) (len=26) "\tstring(StringEnumRandom),", + (string) (len=26) "\tstring(StringEnumValues),", + (string) (len=24) "\tstring(StringEnumHere),", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// StringEnumNames returns a list of possible string values of StringEnum.", + (string) (len=33) "func StringEnumNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_StringEnumNames))", + (string) (len=28) "\tcopy(tmp, _StringEnumNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=28) "\t\"random\": StringEnumRandom,", + (string) (len=28) "\t\"values\": StringEnumValues,", + (string) (len=26) "\t\"here\": StringEnumHere,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=121) "\t// Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to.", + (string) (len=58) "\tif x, ok := _StringEnumValue[strings.ToLower(name)]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=85) "// MustParseStringEnum converts a string to a StringEnum, and panics if is not valid.", + (string) (len=50) "func MustParseStringEnum(name string) StringEnum {", + (string) (len=34) "\tval, err := ParseStringEnum(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errStringEnumNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=36) "func ParseStringEnumExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=42) "func ParseStringEnumDescription() string {", + (string) (len=21) "\treturn `StringEnum.`", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/TestExampleFileMoreOptionsWithForceUpper b/generator/.snapshots/TestExampleFileMoreOptionsWithForceUpper new file mode 100644 index 00000000..c1e7a86f --- /dev/null +++ b/generator/.snapshots/TestExampleFileMoreOptionsWithForceUpper @@ -0,0 +1,2525 @@ +([]string) (len=2523) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=22) "\t\"database/sql/driver\"", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=38) "\t// AnimalCat is a Animal of type Cat.", + (string) (len=24) "\tAnimalCat Animal = iota", + (string) (len=38) "\t// AnimalDog is a Animal of type Dog.", + (string) (len=10) "\tAnimalDog", + (string) (len=40) "\t// AnimalFish is a Animal of type Fish.", + (string) (len=11) "\tAnimalFish", + (string) (len=1) ")", + (string) "", + (string) (len=99) "var ErrInvalidAnimal = fmt.Errorf(\"not a valid Animal, try [%s]\", strings.Join(_AnimalNames, \", \"))", + (string) "", + (string) (len=32) "const _AnimalName = \"CATDOGFISH\"", + (string) "", + (string) (len=28) "var _AnimalNames = []string{", + (string) (len=18) "\t_AnimalName[0:3],", + (string) (len=18) "\t_AnimalName[3:6],", + (string) (len=19) "\t_AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// AnimalNames returns a list of possible string values of Animal.", + (string) (len=29) "func AnimalNames() []string {", + (string) (len=41) "\ttmp := make([]string, len(_AnimalNames))", + (string) (len=24) "\tcopy(tmp, _AnimalNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=30) "\tAnimalCat: _AnimalName[0:3],", + (string) (len=30) "\tAnimalDog: _AnimalName[3:6],", + (string) (len=31) "\tAnimalFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=30) "\t_AnimalName[0:3]: AnimalCat,", + (string) (len=30) "\t_AnimalName[3:6]: AnimalDog,", + (string) (len=31) "\t_AnimalName[6:10]: AnimalFish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=77) "// MustParseAnimal converts a string to a Animal, and panics if is not valid.", + (string) (len=42) "func MustParseAnimal(name string) Animal {", + (string) (len=30) "\tval, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=92) "var errAnimalNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=54) "func (x *Animal) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=16) "\t\t*x = Animal(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase string:", + (string) (len=26) "\t\t*x, err = ParseAnimal(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=34) "\t\t*x, err = ParseAnimal(string(v))", + (string) (len=13) "\tcase Animal:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=14) "\tcase *Animal:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=16) "\t\t*x = Animal(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=17) "\t\t*x = Animal(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=25) "\t\t\treturn errAnimalNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x, err = ParseAnimal(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=47) "func (x Animal) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=32) "func ParseAnimalExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=38) "func ParseAnimalDescription() string {", + (string) (len=18) "\treturn `Animal x`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=50) "\t// CasesTest_lower is a Cases of type Test_lower.", + (string) (len=29) "\tCasesTest_lower Cases = iota", + (string) (len=54) "\t// CasesTest_capital is a Cases of type Test_capital.", + (string) (len=18) "\tCasesTest_capital", + (string) (len=72) "\t// CasesAnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=27) "\tCasesAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidCases = fmt.Errorf(\"not a valid Cases, try [%s]\", strings.Join(_CasesNames, \", \"))", + (string) "", + (string) (len=64) "const _CasesName = \"TEST_LOWERTEST_CAPITALANOTHERLOWERCASESTART\"", + (string) "", + (string) (len=27) "var _CasesNames = []string{", + (string) (len=18) "\t_CasesName[0:10],", + (string) (len=19) "\t_CasesName[10:22],", + (string) (len=19) "\t_CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// CasesNames returns a list of possible string values of Cases.", + (string) (len=28) "func CasesNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_CasesNames))", + (string) (len=23) "\tcopy(tmp, _CasesNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=46) "\tCasesTest_lower: _CasesName[0:10],", + (string) (len=47) "\tCasesTest_capital: _CasesName[10:22],", + (string) (len=47) "\tCasesAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=36) "\t_CasesName[0:10]: CasesTest_lower,", + (string) (len=38) "\t_CasesName[10:22]: CasesTest_capital,", + (string) (len=47) "\t_CasesName[22:43]: CasesAnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseCases converts a string to a Cases, and panics if is not valid.", + (string) (len=40) "func MustParseCases(name string) Cases {", + (string) (len=29) "\tval, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errCasesNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Cases) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Cases(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseCases(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseCases(string(v))", + (string) (len=12) "\tcase Cases:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase *Cases:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Cases(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Cases(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errCasesNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseCases(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Cases) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseCasesExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseCasesDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=40) "\t// ColorBlack is a Color of type Black.", + (string) (len=24) "\tColorBlack Color = iota", + (string) (len=40) "\t// ColorWhite is a Color of type White.", + (string) (len=11) "\tColorWhite", + (string) (len=36) "\t// ColorRed is a Color of type Red.", + (string) (len=9) "\tColorRed", + (string) (len=40) "\t// ColorGreen is a Color of type Green.", + (string) (len=11) "\tColorGreen", + (string) (len=38) "\t// ColorBlue is a Color of type Blue.", + (string) (len=28) "\tColorBlue Color = iota + 29", + (string) (len=38) "\t// ColorGrey is a Color of type Grey.", + (string) (len=10) "\tColorGrey", + (string) (len=42) "\t// ColorYellow is a Color of type Yellow.", + (string) (len=12) "\tColorYellow", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidColor = fmt.Errorf(\"not a valid Color, try [%s]\", strings.Join(_ColorNames, \", \"))", + (string) "", + (string) (len=53) "const _ColorName = \"BLACKWHITEREDGREENBLUEGREYYELLOW\"", + (string) "", + (string) (len=27) "var _ColorNames = []string{", + (string) (len=17) "\t_ColorName[0:5],", + (string) (len=18) "\t_ColorName[5:10],", + (string) (len=19) "\t_ColorName[10:13],", + (string) (len=19) "\t_ColorName[13:18],", + (string) (len=19) "\t_ColorName[18:22],", + (string) (len=19) "\t_ColorName[22:26],", + (string) (len=19) "\t_ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ColorNames returns a list of possible string values of Color.", + (string) (len=28) "func ColorNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ColorNames))", + (string) (len=23) "\tcopy(tmp, _ColorNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=30) "\tColorBlack: _ColorName[0:5],", + (string) (len=31) "\tColorWhite: _ColorName[5:10],", + (string) (len=32) "\tColorRed: _ColorName[10:13],", + (string) (len=32) "\tColorGreen: _ColorName[13:18],", + (string) (len=32) "\tColorBlue: _ColorName[18:22],", + (string) (len=32) "\tColorGrey: _ColorName[22:26],", + (string) (len=32) "\tColorYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=31) "\t_ColorName[0:5]: ColorBlack,", + (string) (len=31) "\t_ColorName[5:10]: ColorWhite,", + (string) (len=29) "\t_ColorName[10:13]: ColorRed,", + (string) (len=31) "\t_ColorName[13:18]: ColorGreen,", + (string) (len=30) "\t_ColorName[18:22]: ColorBlue,", + (string) (len=30) "\t_ColorName[22:26]: ColorGrey,", + (string) (len=32) "\t_ColorName[26:32]: ColorYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseColor converts a string to a Color, and panics if is not valid.", + (string) (len=40) "func MustParseColor(name string) Color {", + (string) (len=29) "\tval, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errColorNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Color) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Color(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseColor(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseColor(string(v))", + (string) (len=12) "\tcase Color:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase *Color:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Color(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Color(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errColorNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseColor(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Color) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseColorExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseColorDescription() string {", + (string) (len=61) "\treturn `Color is an enumeration of colors that are allowed.`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=62) "\t// ColorWithCommentBlack is a ColorWithComment of type Black.", + (string) (len=46) "\tColorWithCommentBlack ColorWithComment = iota", + (string) (len=62) "\t// ColorWithCommentWhite is a ColorWithComment of type White.", + (string) (len=22) "\tColorWithCommentWhite", + (string) (len=58) "\t// ColorWithCommentRed is a ColorWithComment of type Red.", + (string) (len=20) "\tColorWithCommentRed", + (string) (len=62) "\t// ColorWithCommentGreen is a ColorWithComment of type Green.", + (string) (len=22) "\tColorWithCommentGreen", + (string) (len=60) "\t// ColorWithCommentBlue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=50) "\tColorWithCommentBlue ColorWithComment = iota + 29", + (string) (len=60) "\t// ColorWithCommentGrey is a ColorWithComment of type Grey.", + (string) (len=21) "\tColorWithCommentGrey", + (string) (len=64) "\t// ColorWithCommentYellow is a ColorWithComment of type Yellow.", + (string) (len=23) "\tColorWithCommentYellow", + (string) (len=1) ")", + (string) "", + (string) (len=129) "var ErrInvalidColorWithComment = fmt.Errorf(\"not a valid ColorWithComment, try [%s]\", strings.Join(_ColorWithCommentNames, \", \"))", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BLACKWHITEREDGREENBLUEGREYYELLOW\"", + (string) "", + (string) (len=38) "var _ColorWithCommentNames = []string{", + (string) (len=28) "\t_ColorWithCommentName[0:5],", + (string) (len=29) "\t_ColorWithCommentName[5:10],", + (string) (len=30) "\t_ColorWithCommentName[10:13],", + (string) (len=30) "\t_ColorWithCommentName[13:18],", + (string) (len=30) "\t_ColorWithCommentName[18:22],", + (string) (len=30) "\t_ColorWithCommentName[22:26],", + (string) (len=30) "\t_ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=86) "// ColorWithCommentNames returns a list of possible string values of ColorWithComment.", + (string) (len=39) "func ColorWithCommentNames() []string {", + (string) (len=51) "\ttmp := make([]string, len(_ColorWithCommentNames))", + (string) (len=34) "\tcopy(tmp, _ColorWithCommentNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=52) "\tColorWithCommentBlack: _ColorWithCommentName[0:5],", + (string) (len=53) "\tColorWithCommentWhite: _ColorWithCommentName[5:10],", + (string) (len=54) "\tColorWithCommentRed: _ColorWithCommentName[10:13],", + (string) (len=54) "\tColorWithCommentGreen: _ColorWithCommentName[13:18],", + (string) (len=54) "\tColorWithCommentBlue: _ColorWithCommentName[18:22],", + (string) (len=54) "\tColorWithCommentGrey: _ColorWithCommentName[22:26],", + (string) (len=54) "\tColorWithCommentYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=53) "\t_ColorWithCommentName[0:5]: ColorWithCommentBlack,", + (string) (len=53) "\t_ColorWithCommentName[5:10]: ColorWithCommentWhite,", + (string) (len=51) "\t_ColorWithCommentName[10:13]: ColorWithCommentRed,", + (string) (len=53) "\t_ColorWithCommentName[13:18]: ColorWithCommentGreen,", + (string) (len=52) "\t_ColorWithCommentName[18:22]: ColorWithCommentBlue,", + (string) (len=52) "\t_ColorWithCommentName[22:26]: ColorWithCommentGrey,", + (string) (len=54) "\t_ColorWithCommentName[26:32]: ColorWithCommentYellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=97) "// MustParseColorWithComment converts a string to a ColorWithComment, and panics if is not valid.", + (string) (len=62) "func MustParseColorWithComment(name string) ColorWithComment {", + (string) (len=40) "\tval, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=102) "var errColorWithCommentNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=64) "func (x *ColorWithComment) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=26) "\t\t*x = ColorWithComment(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase string:", + (string) (len=36) "\t\t*x, err = ParseColorWithComment(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=44) "\t\t*x, err = ParseColorWithComment(string(v))", + (string) (len=23) "\tcase ColorWithComment:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=24) "\tcase *ColorWithComment:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=26) "\t\t*x = ColorWithComment(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=27) "\t\t*x = ColorWithComment(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=35) "\t\t\treturn errColorWithCommentNilPtr", + (string) (len=3) "\t\t}", + (string) (len=37) "\t\t*x, err = ParseColorWithComment(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=57) "func (x ColorWithComment) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=42) "func ParseColorWithCommentExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=48) "func ParseColorWithCommentDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment2Black is a ColorWithComment2 of type Black.", + (string) (len=48) "\tColorWithComment2Black ColorWithComment2 = iota", + (string) (len=64) "\t// ColorWithComment2White is a ColorWithComment2 of type White.", + (string) (len=23) "\tColorWithComment2White", + (string) (len=60) "\t// ColorWithComment2Red is a ColorWithComment2 of type Red.", + (string) (len=21) "\tColorWithComment2Red", + (string) (len=64) "\t// ColorWithComment2Green is a ColorWithComment2 of type Green.", + (string) (len=23) "\tColorWithComment2Green", + (string) (len=62) "\t// ColorWithComment2Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=52) "\tColorWithComment2Blue ColorWithComment2 = iota + 29", + (string) (len=62) "\t// ColorWithComment2Grey is a ColorWithComment2 of type Grey.", + (string) (len=22) "\tColorWithComment2Grey", + (string) (len=66) "\t// ColorWithComment2Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=24) "\tColorWithComment2Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment2 = fmt.Errorf(\"not a valid ColorWithComment2, try [%s]\", strings.Join(_ColorWithComment2Names, \", \"))", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BLACKWHITEREDGREENBLUEGREYYELLOW\"", + (string) "", + (string) (len=39) "var _ColorWithComment2Names = []string{", + (string) (len=29) "\t_ColorWithComment2Name[0:5],", + (string) (len=30) "\t_ColorWithComment2Name[5:10],", + (string) (len=31) "\t_ColorWithComment2Name[10:13],", + (string) (len=31) "\t_ColorWithComment2Name[13:18],", + (string) (len=31) "\t_ColorWithComment2Name[18:22],", + (string) (len=31) "\t_ColorWithComment2Name[22:26],", + (string) (len=31) "\t_ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment2Names returns a list of possible string values of ColorWithComment2.", + (string) (len=40) "func ColorWithComment2Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment2Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment2Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=54) "\tColorWithComment2Black: _ColorWithComment2Name[0:5],", + (string) (len=55) "\tColorWithComment2White: _ColorWithComment2Name[5:10],", + (string) (len=56) "\tColorWithComment2Red: _ColorWithComment2Name[10:13],", + (string) (len=56) "\tColorWithComment2Green: _ColorWithComment2Name[13:18],", + (string) (len=56) "\tColorWithComment2Blue: _ColorWithComment2Name[18:22],", + (string) (len=56) "\tColorWithComment2Grey: _ColorWithComment2Name[22:26],", + (string) (len=56) "\tColorWithComment2Yellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=55) "\t_ColorWithComment2Name[0:5]: ColorWithComment2Black,", + (string) (len=55) "\t_ColorWithComment2Name[5:10]: ColorWithComment2White,", + (string) (len=53) "\t_ColorWithComment2Name[10:13]: ColorWithComment2Red,", + (string) (len=55) "\t_ColorWithComment2Name[13:18]: ColorWithComment2Green,", + (string) (len=54) "\t_ColorWithComment2Name[18:22]: ColorWithComment2Blue,", + (string) (len=54) "\t_ColorWithComment2Name[22:26]: ColorWithComment2Grey,", + (string) (len=56) "\t_ColorWithComment2Name[26:32]: ColorWithComment2Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment2 converts a string to a ColorWithComment2, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment2(name string) ColorWithComment2 {", + (string) (len=41) "\tval, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment2NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment2) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment2(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment2(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment2(string(v))", + (string) (len=24) "\tcase ColorWithComment2:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=25) "\tcase *ColorWithComment2:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment2(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment2(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment2NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment2(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment2) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment2Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment2Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=64) "\t// ColorWithComment3Black is a ColorWithComment3 of type Black.", + (string) (len=48) "\tColorWithComment3Black ColorWithComment3 = iota", + (string) (len=64) "\t// ColorWithComment3White is a ColorWithComment3 of type White.", + (string) (len=23) "\tColorWithComment3White", + (string) (len=60) "\t// ColorWithComment3Red is a ColorWithComment3 of type Red.", + (string) (len=21) "\tColorWithComment3Red", + (string) (len=64) "\t// ColorWithComment3Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment3Green ColorWithComment3 = iota + 30", + (string) (len=62) "\t// ColorWithComment3Blue is a ColorWithComment3 of type Blue.", + (string) (len=22) "\tColorWithComment3Blue", + (string) (len=62) "\t// ColorWithComment3Grey is a ColorWithComment3 of type Grey.", + (string) (len=22) "\tColorWithComment3Grey", + (string) (len=66) "\t// ColorWithComment3Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=24) "\tColorWithComment3Yellow", + (string) (len=73) "\t// ColorWithComment3BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment3BlueGreen", + (string) (len=73) "\t// ColorWithComment3RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=27) "\tColorWithComment3RedOrange", + (string) (len=82) "\t// ColorWithComment3RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=31) "\tColorWithComment3RedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment3 = fmt.Errorf(\"not a valid ColorWithComment3, try [%s]\", strings.Join(_ColorWithComment3Names, \", \"))", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BLACKWHITEREDGREENBLUEGREYYELLOWBLUE-GREENRED-ORANGERED-ORANGE-BLUE\"", + (string) "", + (string) (len=39) "var _ColorWithComment3Names = []string{", + (string) (len=29) "\t_ColorWithComment3Name[0:5],", + (string) (len=30) "\t_ColorWithComment3Name[5:10],", + (string) (len=31) "\t_ColorWithComment3Name[10:13],", + (string) (len=31) "\t_ColorWithComment3Name[13:18],", + (string) (len=31) "\t_ColorWithComment3Name[18:22],", + (string) (len=31) "\t_ColorWithComment3Name[22:26],", + (string) (len=31) "\t_ColorWithComment3Name[26:32],", + (string) (len=31) "\t_ColorWithComment3Name[32:42],", + (string) (len=31) "\t_ColorWithComment3Name[42:52],", + (string) (len=31) "\t_ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment3Names returns a list of possible string values of ColorWithComment3.", + (string) (len=40) "func ColorWithComment3Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment3Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment3Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=61) "\tColorWithComment3Black: _ColorWithComment3Name[0:5],", + (string) (len=62) "\tColorWithComment3White: _ColorWithComment3Name[5:10],", + (string) (len=63) "\tColorWithComment3Red: _ColorWithComment3Name[10:13],", + (string) (len=63) "\tColorWithComment3Green: _ColorWithComment3Name[13:18],", + (string) (len=63) "\tColorWithComment3Blue: _ColorWithComment3Name[18:22],", + (string) (len=63) "\tColorWithComment3Grey: _ColorWithComment3Name[22:26],", + (string) (len=63) "\tColorWithComment3Yellow: _ColorWithComment3Name[26:32],", + (string) (len=63) "\tColorWithComment3BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=63) "\tColorWithComment3RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=63) "\tColorWithComment3RedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=55) "\t_ColorWithComment3Name[0:5]: ColorWithComment3Black,", + (string) (len=55) "\t_ColorWithComment3Name[5:10]: ColorWithComment3White,", + (string) (len=53) "\t_ColorWithComment3Name[10:13]: ColorWithComment3Red,", + (string) (len=55) "\t_ColorWithComment3Name[13:18]: ColorWithComment3Green,", + (string) (len=54) "\t_ColorWithComment3Name[18:22]: ColorWithComment3Blue,", + (string) (len=54) "\t_ColorWithComment3Name[22:26]: ColorWithComment3Grey,", + (string) (len=56) "\t_ColorWithComment3Name[26:32]: ColorWithComment3Yellow,", + (string) (len=59) "\t_ColorWithComment3Name[32:42]: ColorWithComment3BlueGreen,", + (string) (len=59) "\t_ColorWithComment3Name[42:52]: ColorWithComment3RedOrange,", + (string) (len=63) "\t_ColorWithComment3Name[52:67]: ColorWithComment3RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment3 converts a string to a ColorWithComment3, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment3(name string) ColorWithComment3 {", + (string) (len=41) "\tval, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment3NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment3) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment3(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment3(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment3(string(v))", + (string) (len=24) "\tcase ColorWithComment3:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=25) "\tcase *ColorWithComment3:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment3(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment3(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment3NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment3(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment3) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment3Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment3Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=64) "\t// ColorWithComment4Black is a ColorWithComment4 of type Black.", + (string) (len=23) "\tColorWithComment4Black", + (string) (len=64) "\t// ColorWithComment4White is a ColorWithComment4 of type White.", + (string) (len=23) "\tColorWithComment4White", + (string) (len=60) "\t// ColorWithComment4Red is a ColorWithComment4 of type Red.", + (string) (len=21) "\tColorWithComment4Red", + (string) (len=64) "\t// ColorWithComment4Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=53) "\tColorWithComment4Green ColorWithComment4 = iota + 29", + (string) (len=62) "\t// ColorWithComment4Blue is a ColorWithComment4 of type Blue.", + (string) (len=22) "\tColorWithComment4Blue", + (string) (len=62) "\t// ColorWithComment4Grey is a ColorWithComment4 of type Grey.", + (string) (len=22) "\tColorWithComment4Grey", + (string) (len=66) "\t// ColorWithComment4Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=24) "\tColorWithComment4Yellow", + (string) (len=73) "\t// ColorWithComment4BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=27) "\tColorWithComment4BlueGreen", + (string) (len=73) "\t// ColorWithComment4RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=27) "\tColorWithComment4RedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=132) "var ErrInvalidColorWithComment4 = fmt.Errorf(\"not a valid ColorWithComment4, try [%s]\", strings.Join(_ColorWithComment4Names, \", \"))", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BLACKWHITEREDGREENBLUEGREYYELLOWBLUE-GREENRED-ORANGE\"", + (string) "", + (string) (len=39) "var _ColorWithComment4Names = []string{", + (string) (len=29) "\t_ColorWithComment4Name[0:5],", + (string) (len=30) "\t_ColorWithComment4Name[5:10],", + (string) (len=31) "\t_ColorWithComment4Name[10:13],", + (string) (len=31) "\t_ColorWithComment4Name[13:18],", + (string) (len=31) "\t_ColorWithComment4Name[18:22],", + (string) (len=31) "\t_ColorWithComment4Name[22:26],", + (string) (len=31) "\t_ColorWithComment4Name[26:32],", + (string) (len=31) "\t_ColorWithComment4Name[32:42],", + (string) (len=31) "\t_ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=88) "// ColorWithComment4Names returns a list of possible string values of ColorWithComment4.", + (string) (len=40) "func ColorWithComment4Names() []string {", + (string) (len=52) "\ttmp := make([]string, len(_ColorWithComment4Names))", + (string) (len=35) "\tcopy(tmp, _ColorWithComment4Names)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=57) "\tColorWithComment4Black: _ColorWithComment4Name[0:5],", + (string) (len=58) "\tColorWithComment4White: _ColorWithComment4Name[5:10],", + (string) (len=59) "\tColorWithComment4Red: _ColorWithComment4Name[10:13],", + (string) (len=59) "\tColorWithComment4Green: _ColorWithComment4Name[13:18],", + (string) (len=59) "\tColorWithComment4Blue: _ColorWithComment4Name[18:22],", + (string) (len=59) "\tColorWithComment4Grey: _ColorWithComment4Name[22:26],", + (string) (len=59) "\tColorWithComment4Yellow: _ColorWithComment4Name[26:32],", + (string) (len=59) "\tColorWithComment4BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=59) "\tColorWithComment4RedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=55) "\t_ColorWithComment4Name[0:5]: ColorWithComment4Black,", + (string) (len=55) "\t_ColorWithComment4Name[5:10]: ColorWithComment4White,", + (string) (len=53) "\t_ColorWithComment4Name[10:13]: ColorWithComment4Red,", + (string) (len=55) "\t_ColorWithComment4Name[13:18]: ColorWithComment4Green,", + (string) (len=54) "\t_ColorWithComment4Name[18:22]: ColorWithComment4Blue,", + (string) (len=54) "\t_ColorWithComment4Name[22:26]: ColorWithComment4Grey,", + (string) (len=56) "\t_ColorWithComment4Name[26:32]: ColorWithComment4Yellow,", + (string) (len=59) "\t_ColorWithComment4Name[32:42]: ColorWithComment4BlueGreen,", + (string) (len=59) "\t_ColorWithComment4Name[42:52]: ColorWithComment4RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=99) "// MustParseColorWithComment4 converts a string to a ColorWithComment4, and panics if is not valid.", + (string) (len=64) "func MustParseColorWithComment4(name string) ColorWithComment4 {", + (string) (len=41) "\tval, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=103) "var errColorWithComment4NilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=65) "func (x *ColorWithComment4) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=27) "\t\t*x = ColorWithComment4(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase string:", + (string) (len=37) "\t\t*x, err = ParseColorWithComment4(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=45) "\t\t*x, err = ParseColorWithComment4(string(v))", + (string) (len=24) "\tcase ColorWithComment4:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=25) "\tcase *ColorWithComment4:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=27) "\t\t*x = ColorWithComment4(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=28) "\t\t*x = ColorWithComment4(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=36) "\t\t\treturn errColorWithComment4NilPtr", + (string) (len=3) "\t\t}", + (string) (len=38) "\t\t*x, err = ParseColorWithComment4(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=58) "func (x ColorWithComment4) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=43) "func ParseColorWithComment4Example() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=49) "func ParseColorWithComment4Description() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Enum64bitUnknown is a Enum64bit of type Unknown.", + (string) (len=34) "\tEnum64bitUnknown Enum64bit = iota", + (string) (len=48) "\t// Enum64bitE2P15 is a Enum64bit of type E2P15.", + (string) (len=40) "\tEnum64bitE2P15 Enum64bit = iota + 32767", + (string) (len=48) "\t// Enum64bitE2P16 is a Enum64bit of type E2P16.", + (string) (len=40) "\tEnum64bitE2P16 Enum64bit = iota + 65534", + (string) (len=48) "\t// Enum64bitE2P17 is a Enum64bit of type E2P17.", + (string) (len=41) "\tEnum64bitE2P17 Enum64bit = iota + 131069", + (string) (len=48) "\t// Enum64bitE2P18 is a Enum64bit of type E2P18.", + (string) (len=41) "\tEnum64bitE2P18 Enum64bit = iota + 262140", + (string) (len=48) "\t// Enum64bitE2P19 is a Enum64bit of type E2P19.", + (string) (len=41) "\tEnum64bitE2P19 Enum64bit = iota + 524283", + (string) (len=48) "\t// Enum64bitE2P20 is a Enum64bit of type E2P20.", + (string) (len=42) "\tEnum64bitE2P20 Enum64bit = iota + 1048570", + (string) (len=48) "\t// Enum64bitE2P21 is a Enum64bit of type E2P21.", + (string) (len=42) "\tEnum64bitE2P21 Enum64bit = iota + 2097145", + (string) (len=48) "\t// Enum64bitE2P22 is a Enum64bit of type E2P22.", + (string) (len=43) "\tEnum64bitE2P22 Enum64bit = iota + 33554424", + (string) (len=48) "\t// Enum64bitE2P23 is a Enum64bit of type E2P23.", + (string) (len=43) "\tEnum64bitE2P23 Enum64bit = iota + 67108855", + (string) (len=48) "\t// Enum64bitE2P28 is a Enum64bit of type E2P28.", + (string) (len=44) "\tEnum64bitE2P28 Enum64bit = iota + 536870902", + (string) (len=48) "\t// Enum64bitE2P30 is a Enum64bit of type E2P30.", + (string) (len=45) "\tEnum64bitE2P30 Enum64bit = iota + 1073741813", + (string) (len=48) "\t// Enum64bitE2P31 is a Enum64bit of type E2P31.", + (string) (len=45) "\tEnum64bitE2P31 Enum64bit = iota + 2147483636", + (string) (len=48) "\t// Enum64bitE2P32 is a Enum64bit of type E2P32.", + (string) (len=45) "\tEnum64bitE2P32 Enum64bit = iota + 4294967283", + (string) (len=48) "\t// Enum64bitE2P33 is a Enum64bit of type E2P33.", + (string) (len=45) "\tEnum64bitE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=108) "var ErrInvalidEnum64bit = fmt.Errorf(\"not a valid Enum64bit, try [%s]\", strings.Join(_Enum64bitNames, \", \"))", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UNKNOWNE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=31) "var _Enum64bitNames = []string{", + (string) (len=21) "\t_Enum64bitName[0:7],", + (string) (len=22) "\t_Enum64bitName[7:12],", + (string) (len=23) "\t_Enum64bitName[12:17],", + (string) (len=23) "\t_Enum64bitName[17:22],", + (string) (len=23) "\t_Enum64bitName[22:27],", + (string) (len=23) "\t_Enum64bitName[27:32],", + (string) (len=23) "\t_Enum64bitName[32:37],", + (string) (len=23) "\t_Enum64bitName[37:42],", + (string) (len=23) "\t_Enum64bitName[42:47],", + (string) (len=23) "\t_Enum64bitName[47:52],", + (string) (len=23) "\t_Enum64bitName[52:57],", + (string) (len=23) "\t_Enum64bitName[57:62],", + (string) (len=23) "\t_Enum64bitName[62:67],", + (string) (len=23) "\t_Enum64bitName[67:72],", + (string) (len=23) "\t_Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=72) "// Enum64bitNames returns a list of possible string values of Enum64bit.", + (string) (len=32) "func Enum64bitNames() []string {", + (string) (len=44) "\ttmp := make([]string, len(_Enum64bitNames))", + (string) (len=27) "\tcopy(tmp, _Enum64bitNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=39) "\tEnum64bitUnknown: _Enum64bitName[0:7],", + (string) (len=40) "\tEnum64bitE2P15: _Enum64bitName[7:12],", + (string) (len=41) "\tEnum64bitE2P16: _Enum64bitName[12:17],", + (string) (len=41) "\tEnum64bitE2P17: _Enum64bitName[17:22],", + (string) (len=41) "\tEnum64bitE2P18: _Enum64bitName[22:27],", + (string) (len=41) "\tEnum64bitE2P19: _Enum64bitName[27:32],", + (string) (len=41) "\tEnum64bitE2P20: _Enum64bitName[32:37],", + (string) (len=41) "\tEnum64bitE2P21: _Enum64bitName[37:42],", + (string) (len=41) "\tEnum64bitE2P22: _Enum64bitName[42:47],", + (string) (len=41) "\tEnum64bitE2P23: _Enum64bitName[47:52],", + (string) (len=41) "\tEnum64bitE2P28: _Enum64bitName[52:57],", + (string) (len=41) "\tEnum64bitE2P30: _Enum64bitName[57:62],", + (string) (len=41) "\tEnum64bitE2P31: _Enum64bitName[62:67],", + (string) (len=41) "\tEnum64bitE2P32: _Enum64bitName[67:72],", + (string) (len=41) "\tEnum64bitE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=41) "\t_Enum64bitName[0:7]: Enum64bitUnknown,", + (string) (len=39) "\t_Enum64bitName[7:12]: Enum64bitE2P15,", + (string) (len=39) "\t_Enum64bitName[12:17]: Enum64bitE2P16,", + (string) (len=39) "\t_Enum64bitName[17:22]: Enum64bitE2P17,", + (string) (len=39) "\t_Enum64bitName[22:27]: Enum64bitE2P18,", + (string) (len=39) "\t_Enum64bitName[27:32]: Enum64bitE2P19,", + (string) (len=39) "\t_Enum64bitName[32:37]: Enum64bitE2P20,", + (string) (len=39) "\t_Enum64bitName[37:42]: Enum64bitE2P21,", + (string) (len=39) "\t_Enum64bitName[42:47]: Enum64bitE2P22,", + (string) (len=39) "\t_Enum64bitName[47:52]: Enum64bitE2P23,", + (string) (len=39) "\t_Enum64bitName[52:57]: Enum64bitE2P28,", + (string) (len=39) "\t_Enum64bitName[57:62]: Enum64bitE2P30,", + (string) (len=39) "\t_Enum64bitName[62:67]: Enum64bitE2P31,", + (string) (len=39) "\t_Enum64bitName[67:72]: Enum64bitE2P32,", + (string) (len=39) "\t_Enum64bitName[72:77]: Enum64bitE2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=83) "// MustParseEnum64bit converts a string to a Enum64bit, and panics if is not valid.", + (string) (len=48) "func MustParseEnum64bit(name string) Enum64bit {", + (string) (len=33) "\tval, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=95) "var errEnum64bitNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=57) "func (x *Enum64bit) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=19) "\t\t*x = Enum64bit(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase string:", + (string) (len=29) "\t\t*x, err = ParseEnum64bit(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=37) "\t\t*x, err = ParseEnum64bit(string(v))", + (string) (len=16) "\tcase Enum64bit:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=17) "\tcase *Enum64bit:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=19) "\t\t*x = Enum64bit(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=20) "\t\t*x = Enum64bit(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=28) "\t\t\treturn errEnum64bitNilPtr", + (string) (len=3) "\t\t}", + (string) (len=30) "\t\t*x, err = ParseEnum64bit(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=50) "func (x Enum64bit) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=35) "func ParseEnum64bitExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=41) "func ParseEnum64bitDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// ModelToyota is a Model of type Toyota.", + (string) (len=25) "\tModelToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=40) "\t// ModelChevy is a Model of type Chevy.", + (string) (len=11) "\tModelChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=38) "\t// ModelFord is a Model of type Ford.", + (string) (len=10) "\tModelFord", + (string) (len=1) ")", + (string) "", + (string) (len=96) "var ErrInvalidModel = fmt.Errorf(\"not a valid Model, try [%s]\", strings.Join(_ModelNames, \", \"))", + (string) "", + (string) (len=36) "const _ModelName = \"TOYOTACHEVYFORD\"", + (string) "", + (string) (len=27) "var _ModelNames = []string{", + (string) (len=17) "\t_ModelName[0:6],", + (string) (len=18) "\t_ModelName[6:11],", + (string) (len=19) "\t_ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ModelNames returns a list of possible string values of Model.", + (string) (len=28) "func ModelNames() []string {", + (string) (len=40) "\ttmp := make([]string, len(_ModelNames))", + (string) (len=23) "\tcopy(tmp, _ModelNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=30) "\tModelToyota: _ModelName[0:6],", + (string) (len=31) "\tModelChevy: _ModelName[6:11],", + (string) (len=32) "\tModelFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=32) "\t_ModelName[0:6]: ModelToyota,", + (string) (len=31) "\t_ModelName[6:11]: ModelChevy,", + (string) (len=30) "\t_ModelName[11:15]: ModelFord,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=75) "// MustParseModel converts a string to a Model, and panics if is not valid.", + (string) (len=40) "func MustParseModel(name string) Model {", + (string) (len=29) "\tval, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=91) "var errModelNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=53) "func (x *Model) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=15) "\t\t*x = Model(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase string:", + (string) (len=25) "\t\t*x, err = ParseModel(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=33) "\t\t*x, err = ParseModel(string(v))", + (string) (len=12) "\tcase Model:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase *Model:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\t*x = Model(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=16) "\t\t*x = Model(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=24) "\t\t\treturn errModelNilPtr", + (string) (len=3) "\t\t}", + (string) (len=26) "\t\t*x, err = ParseModel(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=46) "func (x Model) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=31) "func ParseModelExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=37) "func ParseModelDescription() string {", + (string) (len=17) "\treturn `Model x`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=60) "\t// NonASCIIПродам is a NonASCII of type Продам.", + (string) (len=44) "\tNonASCIIПродам NonASCII = iota + 1114", + (string) (len=48) "\t// NonASCII車庫 is a NonASCII of type 車庫.", + (string) (len=37) "\tNonASCII車庫 NonASCII = iota + 299", + (string) (len=52) "\t// NonASCIIԷժան is a NonASCII of type Էժան.", + (string) (len=38) "\tNonASCIIԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=105) "var ErrInvalidNonASCII = fmt.Errorf(\"not a valid NonASCII, try [%s]\", strings.Join(_NonASCIINames, \", \"))", + (string) "", + (string) (len=50) "const _NonASCIIName = \"ПРОДАМ車庫ԷԺԱՆ\"", + (string) "", + (string) (len=30) "var _NonASCIINames = []string{", + (string) (len=21) "\t_NonASCIIName[0:12],", + (string) (len=22) "\t_NonASCIIName[12:18],", + (string) (len=22) "\t_NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=70) "// NonASCIINames returns a list of possible string values of NonASCII.", + (string) (len=31) "func NonASCIINames() []string {", + (string) (len=43) "\ttmp := make([]string, len(_NonASCIINames))", + (string) (len=26) "\tcopy(tmp, _NonASCIINames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=43) "\tNonASCIIПродам: _NonASCIIName[0:12],", + (string) (len=42) "\tNonASCII車庫: _NonASCIIName[12:18],", + (string) (len=42) "\tNonASCIIԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=44) "\t_NonASCIIName[0:12]: NonASCIIПродам,", + (string) (len=38) "\t_NonASCIIName[12:18]: NonASCII車庫,", + (string) (len=40) "\t_NonASCIIName[18:26]: NonASCIIԷժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=81) "// MustParseNonASCII converts a string to a NonASCII, and panics if is not valid.", + (string) (len=46) "func MustParseNonASCII(name string) NonASCII {", + (string) (len=32) "\tval, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=94) "var errNonASCIINilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=56) "func (x *NonASCII) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=18) "\t\t*x = NonASCII(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase string:", + (string) (len=28) "\t\t*x, err = ParseNonASCII(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=36) "\t\t*x, err = ParseNonASCII(string(v))", + (string) (len=15) "\tcase NonASCII:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=16) "\tcase *NonASCII:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=18) "\t\t*x = NonASCII(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=19) "\t\t*x = NonASCII(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=27) "\t\t\treturn errNonASCIINilPtr", + (string) (len=3) "\t\t}", + (string) (len=29) "\t\t*x, err = ParseNonASCII(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=49) "func (x NonASCII) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=34) "func ParseNonASCIIExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=40) "func ParseNonASCIIDescription() string {", + (string) (len=18) "\treturn `NonASCII`", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=61) "\t// SanitizingTestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=39) "\tSanitizingTestHyphen Sanitizing = iota", + (string) (len=63) "\t// SanitizingHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=22) "\tSanitizingHyphenStart", + (string) (len=72) "\t// Sanitizing_UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=27) "\tSanitizing_UnderscoreFirst", + (string) (len=64) "\t// Sanitizing0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=23) "\tSanitizing0NumberFirst", + (string) (len=60) "\t// Sanitizing123456789A is a Sanitizing of type 123456789A.", + (string) (len=21) "\tSanitizing123456789A", + (string) (len=61) "\t// Sanitizing123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=21) "\tSanitizing123123Asdf", + (string) (len=66) "\t// SanitizingEndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=23) "\tSanitizingEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidSanitizing = fmt.Errorf(\"not a valid Sanitizing, try [%s]\", strings.Join(_SanitizingNames, \", \"))", + (string) "", + (string) (len=112) "const _SanitizingName = \"TEST-HYPHEN-HYPHENSTART_UNDERSCOREFIRST0NUMBERFIRST123456789A123123-ASDFENDING-HYPHEN-\"", + (string) "", + (string) (len=32) "var _SanitizingNames = []string{", + (string) (len=23) "\t_SanitizingName[0:11],", + (string) (len=24) "\t_SanitizingName[11:23],", + (string) (len=24) "\t_SanitizingName[23:39],", + (string) (len=24) "\t_SanitizingName[39:51],", + (string) (len=24) "\t_SanitizingName[51:61],", + (string) (len=24) "\t_SanitizingName[61:72],", + (string) (len=24) "\t_SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// SanitizingNames returns a list of possible string values of Sanitizing.", + (string) (len=33) "func SanitizingNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_SanitizingNames))", + (string) (len=28) "\tcopy(tmp, _SanitizingNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=51) "\tSanitizingTestHyphen: _SanitizingName[0:11],", + (string) (len=52) "\tSanitizingHyphenStart: _SanitizingName[11:23],", + (string) (len=52) "\tSanitizing_UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=52) "\tSanitizing0NumberFirst: _SanitizingName[39:51],", + (string) (len=52) "\tSanitizing123456789A: _SanitizingName[51:61],", + (string) (len=52) "\tSanitizing123123Asdf: _SanitizingName[61:72],", + (string) (len=52) "\tSanitizingEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=46) "\t_SanitizingName[0:11]: SanitizingTestHyphen,", + (string) (len=47) "\t_SanitizingName[11:23]: SanitizingHyphenStart,", + (string) (len=52) "\t_SanitizingName[23:39]: Sanitizing_UnderscoreFirst,", + (string) (len=48) "\t_SanitizingName[39:51]: Sanitizing0NumberFirst,", + (string) (len=46) "\t_SanitizingName[51:61]: Sanitizing123456789A,", + (string) (len=46) "\t_SanitizingName[61:72]: Sanitizing123123Asdf,", + (string) (len=48) "\t_SanitizingName[72:86]: SanitizingEndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=85) "// MustParseSanitizing converts a string to a Sanitizing, and panics if is not valid.", + (string) (len=50) "func MustParseSanitizing(name string) Sanitizing {", + (string) (len=34) "\tval, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errSanitizingNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *Sanitizing) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=20) "\t\t*x = Sanitizing(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseSanitizing(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseSanitizing(string(v))", + (string) (len=17) "\tcase Sanitizing:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=18) "\tcase *Sanitizing:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=20) "\t\t*x = Sanitizing(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=21) "\t\t*x = Sanitizing(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errSanitizingNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseSanitizing(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x Sanitizing) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=36) "func ParseSanitizingExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=42) "func ParseSanitizingDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=36) "\t// SodaCoke is a Soda of type Coke.", + (string) (len=21) "\tSodaCoke Soda = iota", + (string) (len=38) "\t// SodaPepsi is a Soda of type Pepsi.", + (string) (len=10) "\tSodaPepsi", + (string) (len=40) "\t// SodaMtnDew is a Soda of type MtnDew.", + (string) (len=11) "\tSodaMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=93) "var ErrInvalidSoda = fmt.Errorf(\"not a valid Soda, try [%s]\", strings.Join(_SodaNames, \", \"))", + (string) "", + (string) (len=35) "const _SodaName = \"COKEPEPSIMTNDEW\"", + (string) "", + (string) (len=26) "var _SodaNames = []string{", + (string) (len=16) "\t_SodaName[0:4],", + (string) (len=16) "\t_SodaName[4:9],", + (string) (len=17) "\t_SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// SodaNames returns a list of possible string values of Soda.", + (string) (len=27) "func SodaNames() []string {", + (string) (len=39) "\ttmp := make([]string, len(_SodaNames))", + (string) (len=22) "\tcopy(tmp, _SodaNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=28) "\tSodaCoke: _SodaName[0:4],", + (string) (len=28) "\tSodaPepsi: _SodaName[4:9],", + (string) (len=29) "\tSodaMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=27) "\t_SodaName[0:4]: SodaCoke,", + (string) (len=28) "\t_SodaName[4:9]: SodaPepsi,", + (string) (len=29) "\t_SodaName[9:15]: SodaMtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=73) "// MustParseSoda converts a string to a Soda, and panics if is not valid.", + (string) (len=38) "func MustParseSoda(name string) Soda {", + (string) (len=28) "\tval, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=90) "var errSodaNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=52) "func (x *Soda) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=14) "\t\t*x = Soda(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase string:", + (string) (len=24) "\t\t*x, err = ParseSoda(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=32) "\t\t*x, err = ParseSoda(string(v))", + (string) (len=11) "\tcase Soda:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=12) "\tcase *Soda:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=14) "\t\t*x = Soda(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=15) "\t\t*x = Soda(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=23) "\t\t\treturn errSodaNilPtr", + (string) (len=3) "\t\t}", + (string) (len=25) "\t\t*x, err = ParseSoda(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=45) "func (x Soda) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=30) "func ParseSodaExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=36) "func ParseSodaDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=68) "\t// StartNotZeroStartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=50) "\tStartNotZeroStartWithNum StartNotZero = iota + 23", + (string) (len=58) "\t// StartNotZeroNextNum is a StartNotZero of type NextNum.", + (string) (len=20) "\tStartNotZeroNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=117) "var ErrInvalidStartNotZero = fmt.Errorf(\"not a valid StartNotZero, try [%s]\", strings.Join(_StartNotZeroNames, \", \"))", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"STARTWITHNUMNEXTNUM\"", + (string) "", + (string) (len=34) "var _StartNotZeroNames = []string{", + (string) (len=25) "\t_StartNotZeroName[0:12],", + (string) (len=26) "\t_StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// StartNotZeroNames returns a list of possible string values of StartNotZero.", + (string) (len=35) "func StartNotZeroNames() []string {", + (string) (len=47) "\ttmp := make([]string, len(_StartNotZeroNames))", + (string) (len=30) "\tcopy(tmp, _StartNotZeroNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=51) "\tStartNotZeroStartWithNum: _StartNotZeroName[0:12],", + (string) (len=52) "\tStartNotZeroNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=52) "\t_StartNotZeroName[0:12]: StartNotZeroStartWithNum,", + (string) (len=47) "\t_StartNotZeroName[12:19]: StartNotZeroNextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=89) "// MustParseStartNotZero converts a string to a StartNotZero, and panics if is not valid.", + (string) (len=54) "func MustParseStartNotZero(name string) StartNotZero {", + (string) (len=36) "\tval, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=98) "var errStartNotZeroNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=60) "func (x *StartNotZero) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=22) "\t\t*x = StartNotZero(0)", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=12) "\tcase int64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase string:", + (string) (len=32) "\t\t*x, err = ParseStartNotZero(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=40) "\t\t*x, err = ParseStartNotZero(string(v))", + (string) (len=19) "\tcase StartNotZero:", + (string) (len=8) "\t\t*x = v", + (string) (len=10) "\tcase int:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=20) "\tcase *StartNotZero:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=11) "\tcase uint:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=13) "\tcase uint64:", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=11) "\tcase *int:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=13) "\tcase *int64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=72) "\tcase float64: // json marshals everything as a float64 if it's a number", + (string) (len=22) "\t\t*x = StartNotZero(v)", + (string) (len=73) "\tcase *float64: // json marshals everything as a float64 if it's a number", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=12) "\tcase *uint:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *uint64:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=23) "\t\t*x = StartNotZero(*v)", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=31) "\t\t\treturn errStartNotZeroNilPtr", + (string) (len=3) "\t\t}", + (string) (len=33) "\t\t*x, err = ParseStartNotZero(*v)", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=53) "func (x StartNotZero) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=38) "func ParseStartNotZeroExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=44) "func ParseStartNotZeroDescription() string {", + (string) (len=10) "\treturn ``", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// StringEnumRandom is a StringEnum of type random.", + (string) (len=39) "\tStringEnumRandom StringEnum = \"random\"", + (string) (len=52) "\t// StringEnumValues is a StringEnum of type values.", + (string) (len=39) "\tStringEnumValues StringEnum = \"values\"", + (string) (len=48) "\t// StringEnumHere is a StringEnum of type here.", + (string) (len=35) "\tStringEnumHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=111) "var ErrInvalidStringEnum = fmt.Errorf(\"not a valid StringEnum, try [%s]\", strings.Join(_StringEnumNames, \", \"))", + (string) "", + (string) (len=32) "var _StringEnumNames = []string{", + (string) (len=26) "\tstring(StringEnumRandom),", + (string) (len=26) "\tstring(StringEnumValues),", + (string) (len=24) "\tstring(StringEnumHere),", + (string) (len=1) "}", + (string) "", + (string) (len=74) "// StringEnumNames returns a list of possible string values of StringEnum.", + (string) (len=33) "func StringEnumNames() []string {", + (string) (len=45) "\ttmp := make([]string, len(_StringEnumNames))", + (string) (len=28) "\tcopy(tmp, _StringEnumNames)", + (string) (len=11) "\treturn tmp", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=28) "\t\"random\": StringEnumRandom,", + (string) (len=28) "\t\"values\": StringEnumValues,", + (string) (len=26) "\t\"here\": StringEnumHere,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=85) "// MustParseStringEnum converts a string to a StringEnum, and panics if is not valid.", + (string) (len=50) "func MustParseStringEnum(name string) StringEnum {", + (string) (len=34) "\tval, err := ParseStringEnum(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\tpanic(err)", + (string) (len=2) "\t}", + (string) (len=11) "\treturn val", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=96) "var errStringEnumNilPtr = errors.New(\"value pointer is nil\") // one per type for package clashes", + (string) "", + (string) (len=41) "// Scan implements the Scanner interface.", + (string) (len=58) "func (x *StringEnum) Scan(value interface{}) (err error) {", + (string) (len=18) "\tif value == nil {", + (string) (len=21) "\t\t*x = StringEnum(\"\")", + (string) (len=8) "\t\treturn", + (string) (len=2) "\t}", + (string) "", + (string) (len=37) "\t// A wider range of scannable types.", + (string) (len=61) "\t// driver.Value values at the top of the list for expediency", + (string) (len=27) "\tswitch v := value.(type) {", + (string) (len=13) "\tcase string:", + (string) (len=30) "\t\t*x, err = ParseStringEnum(v)", + (string) (len=13) "\tcase []byte:", + (string) (len=38) "\t\t*x, err = ParseStringEnum(string(v))", + (string) (len=17) "\tcase StringEnum:", + (string) (len=8) "\t\t*x = v", + (string) (len=18) "\tcase *StringEnum:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=9) "\t\t*x = *v", + (string) (len=14) "\tcase *string:", + (string) (len=15) "\t\tif v == nil {", + (string) (len=29) "\t\t\treturn errStringEnumNilPtr", + (string) (len=3) "\t\t}", + (string) (len=31) "\t\t*x, err = ParseStringEnum(*v)", + (string) (len=9) "\tdefault:", + (string) (len=50) "\t\treturn errors.New(\"invalid type for StringEnum\")", + (string) (len=2) "\t}", + (string) "", + (string) (len=7) "\treturn", + (string) (len=1) "}", + (string) "", + (string) (len=48) "// Value implements the driver Valuer interface.", + (string) (len=51) "func (x StringEnum) Value() (driver.Value, error) {", + (string) (len=23) "\treturn x.String(), nil", + (string) (len=1) "}", + (string) "", + (string) (len=22) "// Additional template", + (string) (len=36) "func ParseStringEnumExample() bool {", + (string) (len=12) "\treturn true", + (string) (len=1) "}", + (string) (len=42) "func ParseStringEnumDescription() string {", + (string) (len=21) "\treturn `StringEnum.`", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/TestNoPrefixExampleFile b/generator/.snapshots/TestNoPrefixExampleFile new file mode 100644 index 00000000..4df6e5c1 --- /dev/null +++ b/generator/.snapshots/TestNoPrefixExampleFile @@ -0,0 +1,1392 @@ +([]string) (len=1390) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Cat is a Animal of type Cat.", + (string) (len=18) "\tCat Animal = iota", + (string) (len=32) "\t// Dog is a Animal of type Dog.", + (string) (len=4) "\tDog", + (string) (len=34) "\t// Fish is a Animal of type Fish.", + (string) (len=5) "\tFish", + (string) (len=1) ")", + (string) "", + (string) (len=55) "var ErrInvalidAnimal = errors.New(\"not a valid Animal\")", + (string) "", + (string) (len=32) "const _AnimalName = \"CatDogFish\"", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=24) "\tCat: _AnimalName[0:3],", + (string) (len=24) "\tDog: _AnimalName[3:6],", + (string) (len=25) "\tFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=41) "\t_AnimalName[0:3]: Cat,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[0:3]): Cat,", + (string) (len=41) "\t_AnimalName[3:6]: Dog,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[3:6]): Dog,", + (string) (len=42) "\t_AnimalName[6:10]: Fish,", + (string) (len=42) "\tstrings.ToLower(_AnimalName[6:10]): Fish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=40) "func (x *Animal) Set(val string) error {", + (string) (len=27) "\tv, err := ParseAnimal(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=36) "func (x *Animal) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=32) "func (x *Animal) Type() string {", + (string) (len=16) "\treturn \"Animal\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=45) "\t// Test_lower is a Cases of type Test_lower.", + (string) (len=24) "\tTest_lower Cases = iota", + (string) (len=49) "\t// Test_capital is a Cases of type Test_capital.", + (string) (len=13) "\tTest_capital", + (string) (len=67) "\t// AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=22) "\tAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidCases = errors.New(\"not a valid Cases\")", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=41) "\tTest_lower: _CasesName[0:10],", + (string) (len=42) "\tTest_capital: _CasesName[10:22],", + (string) (len=42) "\tAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=48) "\t_CasesName[0:10]: Test_lower,", + (string) (len=48) "\tstrings.ToLower(_CasesName[0:10]): Test_lower,", + (string) (len=50) "\t_CasesName[10:22]: Test_capital,", + (string) (len=50) "\tstrings.ToLower(_CasesName[10:22]): Test_capital,", + (string) (len=59) "\t_CasesName[22:43]: AnotherLowerCaseStart,", + (string) (len=59) "\tstrings.ToLower(_CasesName[22:43]): AnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Cases) Set(val string) error {", + (string) (len=26) "\tv, err := ParseCases(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Cases) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Cases) Type() string {", + (string) (len=15) "\treturn \"Cases\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=35) "\t// Black is a Color of type Black.", + (string) (len=19) "\tBlack Color = iota", + (string) (len=35) "\t// White is a Color of type White.", + (string) (len=6) "\tWhite", + (string) (len=31) "\t// Red is a Color of type Red.", + (string) (len=4) "\tRed", + (string) (len=35) "\t// Green is a Color of type Green.", + (string) (len=6) "\tGreen", + (string) (len=33) "\t// Blue is a Color of type Blue.", + (string) (len=23) "\tBlue Color = iota + 29", + (string) (len=33) "\t// Grey is a Color of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=37) "\t// Yellow is a Color of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidColor = errors.New(\"not a valid Color\")", + (string) "", + (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=25) "\tBlack: _ColorName[0:5],", + (string) (len=26) "\tWhite: _ColorName[5:10],", + (string) (len=27) "\tRed: _ColorName[10:13],", + (string) (len=27) "\tGreen: _ColorName[13:18],", + (string) (len=27) "\tBlue: _ColorName[18:22],", + (string) (len=27) "\tGrey: _ColorName[22:26],", + (string) (len=27) "\tYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=43) "\t_ColorName[0:5]: Black,", + (string) (len=43) "\tstrings.ToLower(_ColorName[0:5]): Black,", + (string) (len=43) "\t_ColorName[5:10]: White,", + (string) (len=43) "\tstrings.ToLower(_ColorName[5:10]): White,", + (string) (len=41) "\t_ColorName[10:13]: Red,", + (string) (len=41) "\tstrings.ToLower(_ColorName[10:13]): Red,", + (string) (len=43) "\t_ColorName[13:18]: Green,", + (string) (len=43) "\tstrings.ToLower(_ColorName[13:18]): Green,", + (string) (len=42) "\t_ColorName[18:22]: Blue,", + (string) (len=42) "\tstrings.ToLower(_ColorName[18:22]): Blue,", + (string) (len=42) "\t_ColorName[22:26]: Grey,", + (string) (len=42) "\tstrings.ToLower(_ColorName[22:26]): Grey,", + (string) (len=44) "\t_ColorName[26:32]: Yellow,", + (string) (len=44) "\tstrings.ToLower(_ColorName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Color) Set(val string) error {", + (string) (len=26) "\tv, err := ParseColor(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Color) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Color) Type() string {", + (string) (len=15) "\treturn \"Color\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=46) "\t// Black is a ColorWithComment of type Black.", + (string) (len=30) "\tBlack ColorWithComment = iota", + (string) (len=46) "\t// White is a ColorWithComment of type White.", + (string) (len=6) "\tWhite", + (string) (len=42) "\t// Red is a ColorWithComment of type Red.", + (string) (len=4) "\tRed", + (string) (len=46) "\t// Green is a ColorWithComment of type Green.", + (string) (len=6) "\tGreen", + (string) (len=44) "\t// Blue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=34) "\tBlue ColorWithComment = iota + 29", + (string) (len=44) "\t// Grey is a ColorWithComment of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=48) "\t// Yellow is a ColorWithComment of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=75) "var ErrInvalidColorWithComment = errors.New(\"not a valid ColorWithComment\")", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=36) "\tBlack: _ColorWithCommentName[0:5],", + (string) (len=37) "\tWhite: _ColorWithCommentName[5:10],", + (string) (len=38) "\tRed: _ColorWithCommentName[10:13],", + (string) (len=38) "\tGreen: _ColorWithCommentName[13:18],", + (string) (len=38) "\tBlue: _ColorWithCommentName[18:22],", + (string) (len=38) "\tGrey: _ColorWithCommentName[22:26],", + (string) (len=38) "\tYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=54) "\t_ColorWithCommentName[0:5]: Black,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[0:5]): Black,", + (string) (len=54) "\t_ColorWithCommentName[5:10]: White,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[5:10]): White,", + (string) (len=52) "\t_ColorWithCommentName[10:13]: Red,", + (string) (len=52) "\tstrings.ToLower(_ColorWithCommentName[10:13]): Red,", + (string) (len=54) "\t_ColorWithCommentName[13:18]: Green,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[13:18]): Green,", + (string) (len=53) "\t_ColorWithCommentName[18:22]: Blue,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[18:22]): Blue,", + (string) (len=53) "\t_ColorWithCommentName[22:26]: Grey,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[22:26]): Grey,", + (string) (len=55) "\t_ColorWithCommentName[26:32]: Yellow,", + (string) (len=55) "\tstrings.ToLower(_ColorWithCommentName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", + (string) (len=37) "\tv, err := ParseColorWithComment(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=42) "func (x *ColorWithComment) Type() string {", + (string) (len=26) "\treturn \"ColorWithComment\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment2 of type Black.", + (string) (len=31) "\tBlack ColorWithComment2 = iota", + (string) (len=47) "\t// White is a ColorWithComment2 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment2 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment2 of type Green.", + (string) (len=6) "\tGreen", + (string) (len=45) "\t// Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=35) "\tBlue ColorWithComment2 = iota + 29", + (string) (len=45) "\t// Grey is a ColorWithComment2 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment2 = errors.New(\"not a valid ColorWithComment2\")", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=37) "\tBlack: _ColorWithComment2Name[0:5],", + (string) (len=38) "\tWhite: _ColorWithComment2Name[5:10],", + (string) (len=39) "\tRed: _ColorWithComment2Name[10:13],", + (string) (len=39) "\tGreen: _ColorWithComment2Name[13:18],", + (string) (len=39) "\tBlue: _ColorWithComment2Name[18:22],", + (string) (len=39) "\tGrey: _ColorWithComment2Name[22:26],", + (string) (len=39) "\tYellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=55) "\t_ColorWithComment2Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment2Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment2Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment2Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment2Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment2Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment2Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment2(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment2) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment2\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment3 of type Black.", + (string) (len=31) "\tBlack ColorWithComment3 = iota", + (string) (len=47) "\t// White is a ColorWithComment3 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment3 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment3 = iota + 30", + (string) (len=45) "\t// Blue is a ColorWithComment3 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment3 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=10) "\tRedOrange", + (string) (len=65) "\t// RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=14) "\tRedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment3 = errors.New(\"not a valid ColorWithComment3\")", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=44) "\tBlack: _ColorWithComment3Name[0:5],", + (string) (len=45) "\tWhite: _ColorWithComment3Name[5:10],", + (string) (len=46) "\tRed: _ColorWithComment3Name[10:13],", + (string) (len=46) "\tGreen: _ColorWithComment3Name[13:18],", + (string) (len=46) "\tBlue: _ColorWithComment3Name[18:22],", + (string) (len=46) "\tGrey: _ColorWithComment3Name[22:26],", + (string) (len=46) "\tYellow: _ColorWithComment3Name[26:32],", + (string) (len=46) "\tBlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=46) "\tRedOrange: _ColorWithComment3Name[42:52],", + (string) (len=46) "\tRedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=55) "\t_ColorWithComment3Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment3Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment3Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment3Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment3Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment3Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment3Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment3Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment3Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): RedOrange,", + (string) (len=63) "\t_ColorWithComment3Name[52:67]: RedOrangeBlue,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment3(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment3) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment3\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=47) "\t// Black is a ColorWithComment4 of type Black.", + (string) (len=6) "\tBlack", + (string) (len=47) "\t// White is a ColorWithComment4 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment4 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment4 = iota + 29", + (string) (len=45) "\t// Blue is a ColorWithComment4 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment4 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=10) "\tRedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment4 = errors.New(\"not a valid ColorWithComment4\")", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=40) "\tBlack: _ColorWithComment4Name[0:5],", + (string) (len=41) "\tWhite: _ColorWithComment4Name[5:10],", + (string) (len=42) "\tRed: _ColorWithComment4Name[10:13],", + (string) (len=42) "\tGreen: _ColorWithComment4Name[13:18],", + (string) (len=42) "\tBlue: _ColorWithComment4Name[18:22],", + (string) (len=42) "\tGrey: _ColorWithComment4Name[22:26],", + (string) (len=42) "\tYellow: _ColorWithComment4Name[26:32],", + (string) (len=42) "\tBlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=42) "\tRedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=55) "\t_ColorWithComment4Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment4Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment4Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment4Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment4Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment4Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment4Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment4Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment4Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment4(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment4) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment4\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=43) "\t// Unknown is a Enum64bit of type Unknown.", + (string) (len=25) "\tUnknown Enum64bit = iota", + (string) (len=39) "\t// E2P15 is a Enum64bit of type E2P15.", + (string) (len=31) "\tE2P15 Enum64bit = iota + 32767", + (string) (len=39) "\t// E2P16 is a Enum64bit of type E2P16.", + (string) (len=31) "\tE2P16 Enum64bit = iota + 65534", + (string) (len=39) "\t// E2P17 is a Enum64bit of type E2P17.", + (string) (len=32) "\tE2P17 Enum64bit = iota + 131069", + (string) (len=39) "\t// E2P18 is a Enum64bit of type E2P18.", + (string) (len=32) "\tE2P18 Enum64bit = iota + 262140", + (string) (len=39) "\t// E2P19 is a Enum64bit of type E2P19.", + (string) (len=32) "\tE2P19 Enum64bit = iota + 524283", + (string) (len=39) "\t// E2P20 is a Enum64bit of type E2P20.", + (string) (len=33) "\tE2P20 Enum64bit = iota + 1048570", + (string) (len=39) "\t// E2P21 is a Enum64bit of type E2P21.", + (string) (len=33) "\tE2P21 Enum64bit = iota + 2097145", + (string) (len=39) "\t// E2P22 is a Enum64bit of type E2P22.", + (string) (len=34) "\tE2P22 Enum64bit = iota + 33554424", + (string) (len=39) "\t// E2P23 is a Enum64bit of type E2P23.", + (string) (len=34) "\tE2P23 Enum64bit = iota + 67108855", + (string) (len=39) "\t// E2P28 is a Enum64bit of type E2P28.", + (string) (len=35) "\tE2P28 Enum64bit = iota + 536870902", + (string) (len=39) "\t// E2P30 is a Enum64bit of type E2P30.", + (string) (len=36) "\tE2P30 Enum64bit = iota + 1073741813", + (string) (len=39) "\t// E2P31 is a Enum64bit of type E2P31.", + (string) (len=36) "\tE2P31 Enum64bit = iota + 2147483636", + (string) (len=39) "\t// E2P32 is a Enum64bit of type E2P32.", + (string) (len=36) "\tE2P32 Enum64bit = iota + 4294967283", + (string) (len=39) "\t// E2P33 is a Enum64bit of type E2P33.", + (string) (len=36) "\tE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=61) "var ErrInvalidEnum64bit = errors.New(\"not a valid Enum64bit\")", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=30) "\tUnknown: _Enum64bitName[0:7],", + (string) (len=31) "\tE2P15: _Enum64bitName[7:12],", + (string) (len=32) "\tE2P16: _Enum64bitName[12:17],", + (string) (len=32) "\tE2P17: _Enum64bitName[17:22],", + (string) (len=32) "\tE2P18: _Enum64bitName[22:27],", + (string) (len=32) "\tE2P19: _Enum64bitName[27:32],", + (string) (len=32) "\tE2P20: _Enum64bitName[32:37],", + (string) (len=32) "\tE2P21: _Enum64bitName[37:42],", + (string) (len=32) "\tE2P22: _Enum64bitName[42:47],", + (string) (len=32) "\tE2P23: _Enum64bitName[47:52],", + (string) (len=32) "\tE2P28: _Enum64bitName[52:57],", + (string) (len=32) "\tE2P30: _Enum64bitName[57:62],", + (string) (len=32) "\tE2P31: _Enum64bitName[62:67],", + (string) (len=32) "\tE2P32: _Enum64bitName[67:72],", + (string) (len=32) "\tE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=49) "\t_Enum64bitName[0:7]: Unknown,", + (string) (len=49) "\tstrings.ToLower(_Enum64bitName[0:7]): Unknown,", + (string) (len=47) "\t_Enum64bitName[7:12]: E2P15,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[7:12]): E2P15,", + (string) (len=47) "\t_Enum64bitName[12:17]: E2P16,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[12:17]): E2P16,", + (string) (len=47) "\t_Enum64bitName[17:22]: E2P17,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[17:22]): E2P17,", + (string) (len=47) "\t_Enum64bitName[22:27]: E2P18,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[22:27]): E2P18,", + (string) (len=47) "\t_Enum64bitName[27:32]: E2P19,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[27:32]): E2P19,", + (string) (len=47) "\t_Enum64bitName[32:37]: E2P20,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[32:37]): E2P20,", + (string) (len=47) "\t_Enum64bitName[37:42]: E2P21,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[37:42]): E2P21,", + (string) (len=47) "\t_Enum64bitName[42:47]: E2P22,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[42:47]): E2P22,", + (string) (len=47) "\t_Enum64bitName[47:52]: E2P23,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[47:52]): E2P23,", + (string) (len=47) "\t_Enum64bitName[52:57]: E2P28,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[52:57]): E2P28,", + (string) (len=47) "\t_Enum64bitName[57:62]: E2P30,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[57:62]): E2P30,", + (string) (len=47) "\t_Enum64bitName[62:67]: E2P31,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[62:67]): E2P31,", + (string) (len=47) "\t_Enum64bitName[67:72]: E2P32,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[67:72]): E2P32,", + (string) (len=47) "\t_Enum64bitName[72:77]: E2P33,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[72:77]): E2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=43) "func (x *Enum64bit) Set(val string) error {", + (string) (len=30) "\tv, err := ParseEnum64bit(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=39) "func (x *Enum64bit) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=35) "func (x *Enum64bit) Type() string {", + (string) (len=19) "\treturn \"Enum64bit\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=37) "\t// Toyota is a Model of type Toyota.", + (string) (len=20) "\tToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=35) "\t// Chevy is a Model of type Chevy.", + (string) (len=6) "\tChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=33) "\t// Ford is a Model of type Ford.", + (string) (len=5) "\tFord", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidModel = errors.New(\"not a valid Model\")", + (string) "", + (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=25) "\tToyota: _ModelName[0:6],", + (string) (len=26) "\tChevy: _ModelName[6:11],", + (string) (len=27) "\tFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=44) "\t_ModelName[0:6]: Toyota,", + (string) (len=44) "\tstrings.ToLower(_ModelName[0:6]): Toyota,", + (string) (len=43) "\t_ModelName[6:11]: Chevy,", + (string) (len=43) "\tstrings.ToLower(_ModelName[6:11]): Chevy,", + (string) (len=42) "\t_ModelName[11:15]: Ford,", + (string) (len=42) "\tstrings.ToLower(_ModelName[11:15]): Ford,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Model) Set(val string) error {", + (string) (len=26) "\tv, err := ParseModel(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Model) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Model) Type() string {", + (string) (len=15) "\treturn \"Model\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Продам is a NonASCII of type Продам.", + (string) (len=36) "\tПродам NonASCII = iota + 1114", + (string) (len=40) "\t// 車庫 is a NonASCII of type 車庫.", + (string) (len=29) "\t車庫 NonASCII = iota + 299", + (string) (len=44) "\t// Էժան is a NonASCII of type Էժան.", + (string) (len=30) "\tԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=59) "var ErrInvalidNonASCII = errors.New(\"not a valid NonASCII\")", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=35) "\tПродам: _NonASCIIName[0:12],", + (string) (len=34) "\t車庫: _NonASCIIName[12:18],", + (string) (len=34) "\tԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=53) "\t_NonASCIIName[0:12]: Продам,", + (string) (len=53) "\tstrings.ToLower(_NonASCIIName[0:12]): Продам,", + (string) (len=47) "\t_NonASCIIName[12:18]: 車庫,", + (string) (len=47) "\tstrings.ToLower(_NonASCIIName[12:18]): 車庫,", + (string) (len=49) "\t_NonASCIIName[18:26]: Էժան,", + (string) (len=49) "\tstrings.ToLower(_NonASCIIName[18:26]): Էժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=42) "func (x *NonASCII) Set(val string) error {", + (string) (len=29) "\tv, err := ParseNonASCII(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=38) "func (x *NonASCII) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=34) "func (x *NonASCII) Type() string {", + (string) (len=18) "\treturn \"NonASCII\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=51) "\t// TestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=29) "\tTestHyphen Sanitizing = iota", + (string) (len=54) "\t// XHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=13) "\tXHyphenStart", + (string) (len=63) "\t// X_UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=18) "\tX_UnderscoreFirst", + (string) (len=55) "\t// X0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=14) "\tX0NumberFirst", + (string) (len=51) "\t// X123456789A is a Sanitizing of type 123456789A.", + (string) (len=12) "\tX123456789A", + (string) (len=52) "\t// X123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=12) "\tX123123Asdf", + (string) (len=56) "\t// EndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=13) "\tEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidSanitizing = errors.New(\"not a valid Sanitizing\")", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=42) "\tTestHyphen: _SanitizingName[0:11],", + (string) (len=43) "\tXHyphenStart: _SanitizingName[11:23],", + (string) (len=43) "\tX_UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=43) "\tX0NumberFirst: _SanitizingName[39:51],", + (string) (len=43) "\tX123456789A: _SanitizingName[51:61],", + (string) (len=43) "\tX123123Asdf: _SanitizingName[61:72],", + (string) (len=43) "\tEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=53) "\t_SanitizingName[0:11]: TestHyphen,", + (string) (len=53) "\tstrings.ToLower(_SanitizingName[0:11]): TestHyphen,", + (string) (len=55) "\t_SanitizingName[11:23]: XHyphenStart,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[11:23]): XHyphenStart,", + (string) (len=60) "\t_SanitizingName[23:39]: X_UnderscoreFirst,", + (string) (len=60) "\tstrings.ToLower(_SanitizingName[23:39]): X_UnderscoreFirst,", + (string) (len=56) "\t_SanitizingName[39:51]: X0NumberFirst,", + (string) (len=56) "\tstrings.ToLower(_SanitizingName[39:51]): X0NumberFirst,", + (string) (len=54) "\t_SanitizingName[51:61]: X123456789A,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[51:61]): X123456789A,", + (string) (len=54) "\t_SanitizingName[61:72]: X123123Asdf,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[61:72]): X123123Asdf,", + (string) (len=55) "\t_SanitizingName[72:86]: EndingHyphen,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[72:86]): EndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *Sanitizing) Set(val string) error {", + (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *Sanitizing) Type() string {", + (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Coke is a Soda of type Coke.", + (string) (len=17) "\tCoke Soda = iota", + (string) (len=34) "\t// Pepsi is a Soda of type Pepsi.", + (string) (len=6) "\tPepsi", + (string) (len=36) "\t// MtnDew is a Soda of type MtnDew.", + (string) (len=7) "\tMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=51) "var ErrInvalidSoda = errors.New(\"not a valid Soda\")", + (string) "", + (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=24) "\tCoke: _SodaName[0:4],", + (string) (len=24) "\tPepsi: _SodaName[4:9],", + (string) (len=25) "\tMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=40) "\t_SodaName[0:4]: Coke,", + (string) (len=40) "\tstrings.ToLower(_SodaName[0:4]): Coke,", + (string) (len=41) "\t_SodaName[4:9]: Pepsi,", + (string) (len=41) "\tstrings.ToLower(_SodaName[4:9]): Pepsi,", + (string) (len=42) "\t_SodaName[9:15]: MtnDew,", + (string) (len=42) "\tstrings.ToLower(_SodaName[9:15]): MtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=38) "func (x *Soda) Set(val string) error {", + (string) (len=25) "\tv, err := ParseSoda(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=34) "func (x *Soda) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=30) "func (x *Soda) Type() string {", + (string) (len=14) "\treturn \"Soda\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// StartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=38) "\tStartWithNum StartNotZero = iota + 23", + (string) (len=46) "\t// NextNum is a StartNotZero of type NextNum.", + (string) (len=8) "\tNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=67) "var ErrInvalidStartNotZero = errors.New(\"not a valid StartNotZero\")", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=39) "\tStartWithNum: _StartNotZeroName[0:12],", + (string) (len=40) "\tNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=57) "\t_StartNotZeroName[0:12]: StartWithNum,", + (string) (len=57) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartWithNum,", + (string) (len=52) "\t_StartNotZeroName[12:19]: NextNum,", + (string) (len=52) "\tstrings.ToLower(_StartNotZeroName[12:19]): NextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=46) "func (x *StartNotZero) Set(val string) error {", + (string) (len=33) "\tv, err := ParseStartNotZero(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=42) "func (x *StartNotZero) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=38) "func (x *StartNotZero) Type() string {", + (string) (len=22) "\treturn \"StartNotZero\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// Random is a StringEnum of type random.", + (string) (len=29) "\tRandom StringEnum = \"random\"", + (string) (len=42) "\t// Values is a StringEnum of type values.", + (string) (len=29) "\tValues StringEnum = \"values\"", + (string) (len=38) "\t// Here is a StringEnum of type here.", + (string) (len=25) "\tHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidStringEnum = errors.New(\"not a valid StringEnum\")", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=18) "\t\"random\": Random,", + (string) (len=18) "\t\"values\": Values,", + (string) (len=16) "\t\"here\": Here,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *StringEnum) Set(val string) error {", + (string) (len=31) "\tv, err := ParseStringEnum(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *StringEnum) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *StringEnum) Type() string {", + (string) (len=20) "\treturn \"StringEnum\"", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/TestNoPrefixExampleFileWithSnakeToCamel b/generator/.snapshots/TestNoPrefixExampleFileWithSnakeToCamel new file mode 100644 index 00000000..82a21133 --- /dev/null +++ b/generator/.snapshots/TestNoPrefixExampleFileWithSnakeToCamel @@ -0,0 +1,1392 @@ +([]string) (len=1390) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Cat is a Animal of type Cat.", + (string) (len=18) "\tCat Animal = iota", + (string) (len=32) "\t// Dog is a Animal of type Dog.", + (string) (len=4) "\tDog", + (string) (len=34) "\t// Fish is a Animal of type Fish.", + (string) (len=5) "\tFish", + (string) (len=1) ")", + (string) "", + (string) (len=55) "var ErrInvalidAnimal = errors.New(\"not a valid Animal\")", + (string) "", + (string) (len=32) "const _AnimalName = \"CatDogFish\"", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=24) "\tCat: _AnimalName[0:3],", + (string) (len=24) "\tDog: _AnimalName[3:6],", + (string) (len=25) "\tFish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=41) "\t_AnimalName[0:3]: Cat,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[0:3]): Cat,", + (string) (len=41) "\t_AnimalName[3:6]: Dog,", + (string) (len=41) "\tstrings.ToLower(_AnimalName[3:6]): Dog,", + (string) (len=42) "\t_AnimalName[6:10]: Fish,", + (string) (len=42) "\tstrings.ToLower(_AnimalName[6:10]): Fish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=40) "func (x *Animal) Set(val string) error {", + (string) (len=27) "\tv, err := ParseAnimal(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=36) "func (x *Animal) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=32) "func (x *Animal) Type() string {", + (string) (len=16) "\treturn \"Animal\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=44) "\t// TestLower is a Cases of type Test_lower.", + (string) (len=23) "\tTestLower Cases = iota", + (string) (len=48) "\t// TestCapital is a Cases of type Test_capital.", + (string) (len=12) "\tTestCapital", + (string) (len=67) "\t// AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=22) "\tAnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidCases = errors.New(\"not a valid Cases\")", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=41) "\tTestLower: _CasesName[0:10],", + (string) (len=42) "\tTestCapital: _CasesName[10:22],", + (string) (len=42) "\tAnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=47) "\t_CasesName[0:10]: TestLower,", + (string) (len=47) "\tstrings.ToLower(_CasesName[0:10]): TestLower,", + (string) (len=49) "\t_CasesName[10:22]: TestCapital,", + (string) (len=49) "\tstrings.ToLower(_CasesName[10:22]): TestCapital,", + (string) (len=59) "\t_CasesName[22:43]: AnotherLowerCaseStart,", + (string) (len=59) "\tstrings.ToLower(_CasesName[22:43]): AnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Cases) Set(val string) error {", + (string) (len=26) "\tv, err := ParseCases(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Cases) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Cases) Type() string {", + (string) (len=15) "\treturn \"Cases\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=35) "\t// Black is a Color of type Black.", + (string) (len=19) "\tBlack Color = iota", + (string) (len=35) "\t// White is a Color of type White.", + (string) (len=6) "\tWhite", + (string) (len=31) "\t// Red is a Color of type Red.", + (string) (len=4) "\tRed", + (string) (len=35) "\t// Green is a Color of type Green.", + (string) (len=6) "\tGreen", + (string) (len=33) "\t// Blue is a Color of type Blue.", + (string) (len=23) "\tBlue Color = iota + 29", + (string) (len=33) "\t// Grey is a Color of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=37) "\t// Yellow is a Color of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidColor = errors.New(\"not a valid Color\")", + (string) "", + (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=25) "\tBlack: _ColorName[0:5],", + (string) (len=26) "\tWhite: _ColorName[5:10],", + (string) (len=27) "\tRed: _ColorName[10:13],", + (string) (len=27) "\tGreen: _ColorName[13:18],", + (string) (len=27) "\tBlue: _ColorName[18:22],", + (string) (len=27) "\tGrey: _ColorName[22:26],", + (string) (len=27) "\tYellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=43) "\t_ColorName[0:5]: Black,", + (string) (len=43) "\tstrings.ToLower(_ColorName[0:5]): Black,", + (string) (len=43) "\t_ColorName[5:10]: White,", + (string) (len=43) "\tstrings.ToLower(_ColorName[5:10]): White,", + (string) (len=41) "\t_ColorName[10:13]: Red,", + (string) (len=41) "\tstrings.ToLower(_ColorName[10:13]): Red,", + (string) (len=43) "\t_ColorName[13:18]: Green,", + (string) (len=43) "\tstrings.ToLower(_ColorName[13:18]): Green,", + (string) (len=42) "\t_ColorName[18:22]: Blue,", + (string) (len=42) "\tstrings.ToLower(_ColorName[18:22]): Blue,", + (string) (len=42) "\t_ColorName[22:26]: Grey,", + (string) (len=42) "\tstrings.ToLower(_ColorName[22:26]): Grey,", + (string) (len=44) "\t_ColorName[26:32]: Yellow,", + (string) (len=44) "\tstrings.ToLower(_ColorName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Color) Set(val string) error {", + (string) (len=26) "\tv, err := ParseColor(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Color) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Color) Type() string {", + (string) (len=15) "\treturn \"Color\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=46) "\t// Black is a ColorWithComment of type Black.", + (string) (len=30) "\tBlack ColorWithComment = iota", + (string) (len=46) "\t// White is a ColorWithComment of type White.", + (string) (len=6) "\tWhite", + (string) (len=42) "\t// Red is a ColorWithComment of type Red.", + (string) (len=4) "\tRed", + (string) (len=46) "\t// Green is a ColorWithComment of type Green.", + (string) (len=6) "\tGreen", + (string) (len=44) "\t// Blue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=34) "\tBlue ColorWithComment = iota + 29", + (string) (len=44) "\t// Grey is a ColorWithComment of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=48) "\t// Yellow is a ColorWithComment of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=75) "var ErrInvalidColorWithComment = errors.New(\"not a valid ColorWithComment\")", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=36) "\tBlack: _ColorWithCommentName[0:5],", + (string) (len=37) "\tWhite: _ColorWithCommentName[5:10],", + (string) (len=38) "\tRed: _ColorWithCommentName[10:13],", + (string) (len=38) "\tGreen: _ColorWithCommentName[13:18],", + (string) (len=38) "\tBlue: _ColorWithCommentName[18:22],", + (string) (len=38) "\tGrey: _ColorWithCommentName[22:26],", + (string) (len=38) "\tYellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=54) "\t_ColorWithCommentName[0:5]: Black,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[0:5]): Black,", + (string) (len=54) "\t_ColorWithCommentName[5:10]: White,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[5:10]): White,", + (string) (len=52) "\t_ColorWithCommentName[10:13]: Red,", + (string) (len=52) "\tstrings.ToLower(_ColorWithCommentName[10:13]): Red,", + (string) (len=54) "\t_ColorWithCommentName[13:18]: Green,", + (string) (len=54) "\tstrings.ToLower(_ColorWithCommentName[13:18]): Green,", + (string) (len=53) "\t_ColorWithCommentName[18:22]: Blue,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[18:22]): Blue,", + (string) (len=53) "\t_ColorWithCommentName[22:26]: Grey,", + (string) (len=53) "\tstrings.ToLower(_ColorWithCommentName[22:26]): Grey,", + (string) (len=55) "\t_ColorWithCommentName[26:32]: Yellow,", + (string) (len=55) "\tstrings.ToLower(_ColorWithCommentName[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", + (string) (len=37) "\tv, err := ParseColorWithComment(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=42) "func (x *ColorWithComment) Type() string {", + (string) (len=26) "\treturn \"ColorWithComment\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment2 of type Black.", + (string) (len=31) "\tBlack ColorWithComment2 = iota", + (string) (len=47) "\t// White is a ColorWithComment2 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment2 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment2 of type Green.", + (string) (len=6) "\tGreen", + (string) (len=45) "\t// Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=35) "\tBlue ColorWithComment2 = iota + 29", + (string) (len=45) "\t// Grey is a ColorWithComment2 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment2 = errors.New(\"not a valid ColorWithComment2\")", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=37) "\tBlack: _ColorWithComment2Name[0:5],", + (string) (len=38) "\tWhite: _ColorWithComment2Name[5:10],", + (string) (len=39) "\tRed: _ColorWithComment2Name[10:13],", + (string) (len=39) "\tGreen: _ColorWithComment2Name[13:18],", + (string) (len=39) "\tBlue: _ColorWithComment2Name[18:22],", + (string) (len=39) "\tGrey: _ColorWithComment2Name[22:26],", + (string) (len=39) "\tYellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=55) "\t_ColorWithComment2Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment2Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment2Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment2Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment2Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment2Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment2Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment2(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment2) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment2\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=47) "\t// Black is a ColorWithComment3 of type Black.", + (string) (len=31) "\tBlack ColorWithComment3 = iota", + (string) (len=47) "\t// White is a ColorWithComment3 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment3 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment3 = iota + 30", + (string) (len=45) "\t// Blue is a ColorWithComment3 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment3 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=10) "\tRedOrange", + (string) (len=65) "\t// RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=14) "\tRedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment3 = errors.New(\"not a valid ColorWithComment3\")", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=44) "\tBlack: _ColorWithComment3Name[0:5],", + (string) (len=45) "\tWhite: _ColorWithComment3Name[5:10],", + (string) (len=46) "\tRed: _ColorWithComment3Name[10:13],", + (string) (len=46) "\tGreen: _ColorWithComment3Name[13:18],", + (string) (len=46) "\tBlue: _ColorWithComment3Name[18:22],", + (string) (len=46) "\tGrey: _ColorWithComment3Name[22:26],", + (string) (len=46) "\tYellow: _ColorWithComment3Name[26:32],", + (string) (len=46) "\tBlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=46) "\tRedOrange: _ColorWithComment3Name[42:52],", + (string) (len=46) "\tRedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=55) "\t_ColorWithComment3Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment3Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment3Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment3Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment3Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment3Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment3Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment3Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment3Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): RedOrange,", + (string) (len=63) "\t_ColorWithComment3Name[52:67]: RedOrangeBlue,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment3(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment3) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment3\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=47) "\t// Black is a ColorWithComment4 of type Black.", + (string) (len=6) "\tBlack", + (string) (len=47) "\t// White is a ColorWithComment4 of type White.", + (string) (len=6) "\tWhite", + (string) (len=43) "\t// Red is a ColorWithComment4 of type Red.", + (string) (len=4) "\tRed", + (string) (len=47) "\t// Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=36) "\tGreen ColorWithComment4 = iota + 29", + (string) (len=45) "\t// Blue is a ColorWithComment4 of type Blue.", + (string) (len=5) "\tBlue", + (string) (len=45) "\t// Grey is a ColorWithComment4 of type Grey.", + (string) (len=5) "\tGrey", + (string) (len=49) "\t// Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=7) "\tYellow", + (string) (len=56) "\t// BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=10) "\tBlueGreen", + (string) (len=56) "\t// RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=10) "\tRedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment4 = errors.New(\"not a valid ColorWithComment4\")", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=40) "\tBlack: _ColorWithComment4Name[0:5],", + (string) (len=41) "\tWhite: _ColorWithComment4Name[5:10],", + (string) (len=42) "\tRed: _ColorWithComment4Name[10:13],", + (string) (len=42) "\tGreen: _ColorWithComment4Name[13:18],", + (string) (len=42) "\tBlue: _ColorWithComment4Name[18:22],", + (string) (len=42) "\tGrey: _ColorWithComment4Name[22:26],", + (string) (len=42) "\tYellow: _ColorWithComment4Name[26:32],", + (string) (len=42) "\tBlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=42) "\tRedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=55) "\t_ColorWithComment4Name[0:5]: Black,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): Black,", + (string) (len=55) "\t_ColorWithComment4Name[5:10]: White,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): White,", + (string) (len=53) "\t_ColorWithComment4Name[10:13]: Red,", + (string) (len=53) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): Red,", + (string) (len=55) "\t_ColorWithComment4Name[13:18]: Green,", + (string) (len=55) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): Green,", + (string) (len=54) "\t_ColorWithComment4Name[18:22]: Blue,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): Blue,", + (string) (len=54) "\t_ColorWithComment4Name[22:26]: Grey,", + (string) (len=54) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): Grey,", + (string) (len=56) "\t_ColorWithComment4Name[26:32]: Yellow,", + (string) (len=56) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): Yellow,", + (string) (len=59) "\t_ColorWithComment4Name[32:42]: BlueGreen,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): BlueGreen,", + (string) (len=59) "\t_ColorWithComment4Name[42:52]: RedOrange,", + (string) (len=59) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment4(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment4) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment4\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=43) "\t// Unknown is a Enum64bit of type Unknown.", + (string) (len=25) "\tUnknown Enum64bit = iota", + (string) (len=39) "\t// E2P15 is a Enum64bit of type E2P15.", + (string) (len=31) "\tE2P15 Enum64bit = iota + 32767", + (string) (len=39) "\t// E2P16 is a Enum64bit of type E2P16.", + (string) (len=31) "\tE2P16 Enum64bit = iota + 65534", + (string) (len=39) "\t// E2P17 is a Enum64bit of type E2P17.", + (string) (len=32) "\tE2P17 Enum64bit = iota + 131069", + (string) (len=39) "\t// E2P18 is a Enum64bit of type E2P18.", + (string) (len=32) "\tE2P18 Enum64bit = iota + 262140", + (string) (len=39) "\t// E2P19 is a Enum64bit of type E2P19.", + (string) (len=32) "\tE2P19 Enum64bit = iota + 524283", + (string) (len=39) "\t// E2P20 is a Enum64bit of type E2P20.", + (string) (len=33) "\tE2P20 Enum64bit = iota + 1048570", + (string) (len=39) "\t// E2P21 is a Enum64bit of type E2P21.", + (string) (len=33) "\tE2P21 Enum64bit = iota + 2097145", + (string) (len=39) "\t// E2P22 is a Enum64bit of type E2P22.", + (string) (len=34) "\tE2P22 Enum64bit = iota + 33554424", + (string) (len=39) "\t// E2P23 is a Enum64bit of type E2P23.", + (string) (len=34) "\tE2P23 Enum64bit = iota + 67108855", + (string) (len=39) "\t// E2P28 is a Enum64bit of type E2P28.", + (string) (len=35) "\tE2P28 Enum64bit = iota + 536870902", + (string) (len=39) "\t// E2P30 is a Enum64bit of type E2P30.", + (string) (len=36) "\tE2P30 Enum64bit = iota + 1073741813", + (string) (len=39) "\t// E2P31 is a Enum64bit of type E2P31.", + (string) (len=36) "\tE2P31 Enum64bit = iota + 2147483636", + (string) (len=39) "\t// E2P32 is a Enum64bit of type E2P32.", + (string) (len=36) "\tE2P32 Enum64bit = iota + 4294967283", + (string) (len=39) "\t// E2P33 is a Enum64bit of type E2P33.", + (string) (len=36) "\tE2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=61) "var ErrInvalidEnum64bit = errors.New(\"not a valid Enum64bit\")", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=30) "\tUnknown: _Enum64bitName[0:7],", + (string) (len=31) "\tE2P15: _Enum64bitName[7:12],", + (string) (len=32) "\tE2P16: _Enum64bitName[12:17],", + (string) (len=32) "\tE2P17: _Enum64bitName[17:22],", + (string) (len=32) "\tE2P18: _Enum64bitName[22:27],", + (string) (len=32) "\tE2P19: _Enum64bitName[27:32],", + (string) (len=32) "\tE2P20: _Enum64bitName[32:37],", + (string) (len=32) "\tE2P21: _Enum64bitName[37:42],", + (string) (len=32) "\tE2P22: _Enum64bitName[42:47],", + (string) (len=32) "\tE2P23: _Enum64bitName[47:52],", + (string) (len=32) "\tE2P28: _Enum64bitName[52:57],", + (string) (len=32) "\tE2P30: _Enum64bitName[57:62],", + (string) (len=32) "\tE2P31: _Enum64bitName[62:67],", + (string) (len=32) "\tE2P32: _Enum64bitName[67:72],", + (string) (len=32) "\tE2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=49) "\t_Enum64bitName[0:7]: Unknown,", + (string) (len=49) "\tstrings.ToLower(_Enum64bitName[0:7]): Unknown,", + (string) (len=47) "\t_Enum64bitName[7:12]: E2P15,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[7:12]): E2P15,", + (string) (len=47) "\t_Enum64bitName[12:17]: E2P16,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[12:17]): E2P16,", + (string) (len=47) "\t_Enum64bitName[17:22]: E2P17,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[17:22]): E2P17,", + (string) (len=47) "\t_Enum64bitName[22:27]: E2P18,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[22:27]): E2P18,", + (string) (len=47) "\t_Enum64bitName[27:32]: E2P19,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[27:32]): E2P19,", + (string) (len=47) "\t_Enum64bitName[32:37]: E2P20,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[32:37]): E2P20,", + (string) (len=47) "\t_Enum64bitName[37:42]: E2P21,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[37:42]): E2P21,", + (string) (len=47) "\t_Enum64bitName[42:47]: E2P22,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[42:47]): E2P22,", + (string) (len=47) "\t_Enum64bitName[47:52]: E2P23,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[47:52]): E2P23,", + (string) (len=47) "\t_Enum64bitName[52:57]: E2P28,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[52:57]): E2P28,", + (string) (len=47) "\t_Enum64bitName[57:62]: E2P30,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[57:62]): E2P30,", + (string) (len=47) "\t_Enum64bitName[62:67]: E2P31,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[62:67]): E2P31,", + (string) (len=47) "\t_Enum64bitName[67:72]: E2P32,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[67:72]): E2P32,", + (string) (len=47) "\t_Enum64bitName[72:77]: E2P33,", + (string) (len=47) "\tstrings.ToLower(_Enum64bitName[72:77]): E2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=43) "func (x *Enum64bit) Set(val string) error {", + (string) (len=30) "\tv, err := ParseEnum64bit(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=39) "func (x *Enum64bit) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=35) "func (x *Enum64bit) Type() string {", + (string) (len=19) "\treturn \"Enum64bit\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=37) "\t// Toyota is a Model of type Toyota.", + (string) (len=20) "\tToyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=35) "\t// Chevy is a Model of type Chevy.", + (string) (len=6) "\tChevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=33) "\t// Ford is a Model of type Ford.", + (string) (len=5) "\tFord", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidModel = errors.New(\"not a valid Model\")", + (string) "", + (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=25) "\tToyota: _ModelName[0:6],", + (string) (len=26) "\tChevy: _ModelName[6:11],", + (string) (len=27) "\tFord: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=44) "\t_ModelName[0:6]: Toyota,", + (string) (len=44) "\tstrings.ToLower(_ModelName[0:6]): Toyota,", + (string) (len=43) "\t_ModelName[6:11]: Chevy,", + (string) (len=43) "\tstrings.ToLower(_ModelName[6:11]): Chevy,", + (string) (len=42) "\t_ModelName[11:15]: Ford,", + (string) (len=42) "\tstrings.ToLower(_ModelName[11:15]): Ford,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Model) Set(val string) error {", + (string) (len=26) "\tv, err := ParseModel(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Model) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Model) Type() string {", + (string) (len=15) "\treturn \"Model\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// Продам is a NonASCII of type Продам.", + (string) (len=36) "\tПродам NonASCII = iota + 1114", + (string) (len=40) "\t// 車庫 is a NonASCII of type 車庫.", + (string) (len=29) "\t車庫 NonASCII = iota + 299", + (string) (len=44) "\t// Էժան is a NonASCII of type Էժան.", + (string) (len=30) "\tԷժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=59) "var ErrInvalidNonASCII = errors.New(\"not a valid NonASCII\")", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=35) "\tПродам: _NonASCIIName[0:12],", + (string) (len=34) "\t車庫: _NonASCIIName[12:18],", + (string) (len=34) "\tԷժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=53) "\t_NonASCIIName[0:12]: Продам,", + (string) (len=53) "\tstrings.ToLower(_NonASCIIName[0:12]): Продам,", + (string) (len=47) "\t_NonASCIIName[12:18]: 車庫,", + (string) (len=47) "\tstrings.ToLower(_NonASCIIName[12:18]): 車庫,", + (string) (len=49) "\t_NonASCIIName[18:26]: Էժան,", + (string) (len=49) "\tstrings.ToLower(_NonASCIIName[18:26]): Էժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=42) "func (x *NonASCII) Set(val string) error {", + (string) (len=29) "\tv, err := ParseNonASCII(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=38) "func (x *NonASCII) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=34) "func (x *NonASCII) Type() string {", + (string) (len=18) "\treturn \"NonASCII\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=51) "\t// TestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=29) "\tTestHyphen Sanitizing = iota", + (string) (len=54) "\t// XHyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=13) "\tXHyphenStart", + (string) (len=62) "\t// XUnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=17) "\tXUnderscoreFirst", + (string) (len=55) "\t// X0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=14) "\tX0NumberFirst", + (string) (len=51) "\t// X123456789A is a Sanitizing of type 123456789A.", + (string) (len=12) "\tX123456789A", + (string) (len=52) "\t// X123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=12) "\tX123123Asdf", + (string) (len=56) "\t// EndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=13) "\tEndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidSanitizing = errors.New(\"not a valid Sanitizing\")", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=41) "\tTestHyphen: _SanitizingName[0:11],", + (string) (len=42) "\tXHyphenStart: _SanitizingName[11:23],", + (string) (len=42) "\tXUnderscoreFirst: _SanitizingName[23:39],", + (string) (len=42) "\tX0NumberFirst: _SanitizingName[39:51],", + (string) (len=42) "\tX123456789A: _SanitizingName[51:61],", + (string) (len=42) "\tX123123Asdf: _SanitizingName[61:72],", + (string) (len=42) "\tEndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=53) "\t_SanitizingName[0:11]: TestHyphen,", + (string) (len=53) "\tstrings.ToLower(_SanitizingName[0:11]): TestHyphen,", + (string) (len=55) "\t_SanitizingName[11:23]: XHyphenStart,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[11:23]): XHyphenStart,", + (string) (len=59) "\t_SanitizingName[23:39]: XUnderscoreFirst,", + (string) (len=59) "\tstrings.ToLower(_SanitizingName[23:39]): XUnderscoreFirst,", + (string) (len=56) "\t_SanitizingName[39:51]: X0NumberFirst,", + (string) (len=56) "\tstrings.ToLower(_SanitizingName[39:51]): X0NumberFirst,", + (string) (len=54) "\t_SanitizingName[51:61]: X123456789A,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[51:61]): X123456789A,", + (string) (len=54) "\t_SanitizingName[61:72]: X123123Asdf,", + (string) (len=54) "\tstrings.ToLower(_SanitizingName[61:72]): X123123Asdf,", + (string) (len=55) "\t_SanitizingName[72:86]: EndingHyphen,", + (string) (len=55) "\tstrings.ToLower(_SanitizingName[72:86]): EndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *Sanitizing) Set(val string) error {", + (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *Sanitizing) Type() string {", + (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=32) "\t// Coke is a Soda of type Coke.", + (string) (len=17) "\tCoke Soda = iota", + (string) (len=34) "\t// Pepsi is a Soda of type Pepsi.", + (string) (len=6) "\tPepsi", + (string) (len=36) "\t// MtnDew is a Soda of type MtnDew.", + (string) (len=7) "\tMtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=51) "var ErrInvalidSoda = errors.New(\"not a valid Soda\")", + (string) "", + (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=24) "\tCoke: _SodaName[0:4],", + (string) (len=24) "\tPepsi: _SodaName[4:9],", + (string) (len=25) "\tMtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=40) "\t_SodaName[0:4]: Coke,", + (string) (len=40) "\tstrings.ToLower(_SodaName[0:4]): Coke,", + (string) (len=41) "\t_SodaName[4:9]: Pepsi,", + (string) (len=41) "\tstrings.ToLower(_SodaName[4:9]): Pepsi,", + (string) (len=42) "\t_SodaName[9:15]: MtnDew,", + (string) (len=42) "\tstrings.ToLower(_SodaName[9:15]): MtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=38) "func (x *Soda) Set(val string) error {", + (string) (len=25) "\tv, err := ParseSoda(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=34) "func (x *Soda) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=30) "func (x *Soda) Type() string {", + (string) (len=14) "\treturn \"Soda\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// StartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=38) "\tStartWithNum StartNotZero = iota + 23", + (string) (len=46) "\t// NextNum is a StartNotZero of type NextNum.", + (string) (len=8) "\tNextNum", + (string) (len=1) ")", + (string) "", + (string) (len=67) "var ErrInvalidStartNotZero = errors.New(\"not a valid StartNotZero\")", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=39) "\tStartWithNum: _StartNotZeroName[0:12],", + (string) (len=40) "\tNextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=57) "\t_StartNotZeroName[0:12]: StartWithNum,", + (string) (len=57) "\tstrings.ToLower(_StartNotZeroName[0:12]): StartWithNum,", + (string) (len=52) "\t_StartNotZeroName[12:19]: NextNum,", + (string) (len=52) "\tstrings.ToLower(_StartNotZeroName[12:19]): NextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=46) "func (x *StartNotZero) Set(val string) error {", + (string) (len=33) "\tv, err := ParseStartNotZero(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=42) "func (x *StartNotZero) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=38) "func (x *StartNotZero) Type() string {", + (string) (len=22) "\treturn \"StartNotZero\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=42) "\t// Random is a StringEnum of type random.", + (string) (len=29) "\tRandom StringEnum = \"random\"", + (string) (len=42) "\t// Values is a StringEnum of type values.", + (string) (len=29) "\tValues StringEnum = \"values\"", + (string) (len=38) "\t// Here is a StringEnum of type here.", + (string) (len=25) "\tHere StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidStringEnum = errors.New(\"not a valid StringEnum\")", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=18) "\t\"random\": Random,", + (string) (len=18) "\t\"values\": Values,", + (string) (len=16) "\t\"here\": Here,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *StringEnum) Set(val string) error {", + (string) (len=31) "\tv, err := ParseStringEnum(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *StringEnum) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *StringEnum) Type() string {", + (string) (len=20) "\treturn \"StringEnum\"", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/TestReplacePrefixExampleFile b/generator/.snapshots/TestReplacePrefixExampleFile new file mode 100644 index 00000000..f8228029 --- /dev/null +++ b/generator/.snapshots/TestReplacePrefixExampleFile @@ -0,0 +1,1392 @@ +([]string) (len=1390) { + (string) (len=41) "// Code generated by go-enum DO NOT EDIT.", + (string) (len=13) "// Version: -", + (string) (len=14) "// Revision: -", + (string) (len=16) "// Build Date: -", + (string) (len=14) "// Built By: -", + (string) "", + (string) (len=17) "package generator", + (string) "", + (string) (len=8) "import (", + (string) (len=9) "\t\"errors\"", + (string) (len=6) "\t\"fmt\"", + (string) (len=10) "\t\"strings\"", + (string) (len=1) ")", + (string) "", + (string) (len=7) "const (", + (string) (len=41) "\t// MyPrefix_Cat is a Animal of type Cat.", + (string) (len=27) "\tMyPrefix_Cat Animal = iota", + (string) (len=41) "\t// MyPrefix_Dog is a Animal of type Dog.", + (string) (len=13) "\tMyPrefix_Dog", + (string) (len=43) "\t// MyPrefix_Fish is a Animal of type Fish.", + (string) (len=14) "\tMyPrefix_Fish", + (string) (len=1) ")", + (string) "", + (string) (len=55) "var ErrInvalidAnimal = errors.New(\"not a valid Animal\")", + (string) "", + (string) (len=32) "const _AnimalName = \"CatDogFish\"", + (string) "", + (string) (len=35) "var _AnimalMap = map[Animal]string{", + (string) (len=33) "\tMyPrefix_Cat: _AnimalName[0:3],", + (string) (len=33) "\tMyPrefix_Dog: _AnimalName[3:6],", + (string) (len=34) "\tMyPrefix_Fish: _AnimalName[6:10],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=33) "func (x Animal) String() string {", + (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=32) "func (x Animal) IsValid() bool {", + (string) (len=23) "\t_, ok := _AnimalMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=37) "var _AnimalValue = map[string]Animal{", + (string) (len=50) "\t_AnimalName[0:3]: MyPrefix_Cat,", + (string) (len=50) "\tstrings.ToLower(_AnimalName[0:3]): MyPrefix_Cat,", + (string) (len=50) "\t_AnimalName[3:6]: MyPrefix_Dog,", + (string) (len=50) "\tstrings.ToLower(_AnimalName[3:6]): MyPrefix_Dog,", + (string) (len=51) "\t_AnimalName[6:10]: MyPrefix_Fish,", + (string) (len=51) "\tstrings.ToLower(_AnimalName[6:10]): MyPrefix_Fish,", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// ParseAnimal attempts to convert a string to a Animal.", + (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", + (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=65) "\treturn Animal(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidAnimal)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=30) "\ttmp, err := ParseAnimal(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=40) "func (x *Animal) Set(val string) error {", + (string) (len=27) "\tv, err := ParseAnimal(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=36) "func (x *Animal) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=32) "func (x *Animal) Type() string {", + (string) (len=16) "\treturn \"Animal\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=54) "\t// MyPrefix_Test_lower is a Cases of type Test_lower.", + (string) (len=33) "\tMyPrefix_Test_lower Cases = iota", + (string) (len=58) "\t// MyPrefix_Test_capital is a Cases of type Test_capital.", + (string) (len=22) "\tMyPrefix_Test_capital", + (string) (len=76) "\t// MyPrefix_AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", + (string) (len=31) "\tMyPrefix_AnotherLowerCaseStart", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidCases = errors.New(\"not a valid Cases\")", + (string) "", + (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", + (string) "", + (string) (len=33) "var _CasesMap = map[Cases]string{", + (string) (len=50) "\tMyPrefix_Test_lower: _CasesName[0:10],", + (string) (len=51) "\tMyPrefix_Test_capital: _CasesName[10:22],", + (string) (len=51) "\tMyPrefix_AnotherLowerCaseStart: _CasesName[22:43],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Cases) String() string {", + (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Cases) IsValid() bool {", + (string) (len=22) "\t_, ok := _CasesMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _CasesValue = map[string]Cases{", + (string) (len=57) "\t_CasesName[0:10]: MyPrefix_Test_lower,", + (string) (len=57) "\tstrings.ToLower(_CasesName[0:10]): MyPrefix_Test_lower,", + (string) (len=59) "\t_CasesName[10:22]: MyPrefix_Test_capital,", + (string) (len=59) "\tstrings.ToLower(_CasesName[10:22]): MyPrefix_Test_capital,", + (string) (len=68) "\t_CasesName[22:43]: MyPrefix_AnotherLowerCaseStart,", + (string) (len=68) "\tstrings.ToLower(_CasesName[22:43]): MyPrefix_AnotherLowerCaseStart,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseCases attempts to convert a string to a Cases.", + (string) (len=45) "func ParseCases(name string) (Cases, error) {", + (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Cases(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidCases)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseCases(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Cases) Set(val string) error {", + (string) (len=26) "\tv, err := ParseCases(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Cases) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Cases) Type() string {", + (string) (len=15) "\treturn \"Cases\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=44) "\t// MyPrefix_Black is a Color of type Black.", + (string) (len=28) "\tMyPrefix_Black Color = iota", + (string) (len=44) "\t// MyPrefix_White is a Color of type White.", + (string) (len=15) "\tMyPrefix_White", + (string) (len=40) "\t// MyPrefix_Red is a Color of type Red.", + (string) (len=13) "\tMyPrefix_Red", + (string) (len=44) "\t// MyPrefix_Green is a Color of type Green.", + (string) (len=15) "\tMyPrefix_Green", + (string) (len=42) "\t// MyPrefix_Blue is a Color of type Blue.", + (string) (len=32) "\tMyPrefix_Blue Color = iota + 29", + (string) (len=42) "\t// MyPrefix_Grey is a Color of type Grey.", + (string) (len=14) "\tMyPrefix_Grey", + (string) (len=46) "\t// MyPrefix_Yellow is a Color of type Yellow.", + (string) (len=16) "\tMyPrefix_Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidColor = errors.New(\"not a valid Color\")", + (string) "", + (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=33) "var _ColorMap = map[Color]string{", + (string) (len=34) "\tMyPrefix_Black: _ColorName[0:5],", + (string) (len=35) "\tMyPrefix_White: _ColorName[5:10],", + (string) (len=36) "\tMyPrefix_Red: _ColorName[10:13],", + (string) (len=36) "\tMyPrefix_Green: _ColorName[13:18],", + (string) (len=36) "\tMyPrefix_Blue: _ColorName[18:22],", + (string) (len=36) "\tMyPrefix_Grey: _ColorName[22:26],", + (string) (len=36) "\tMyPrefix_Yellow: _ColorName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Color) String() string {", + (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Color) IsValid() bool {", + (string) (len=22) "\t_, ok := _ColorMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ColorValue = map[string]Color{", + (string) (len=52) "\t_ColorName[0:5]: MyPrefix_Black,", + (string) (len=52) "\tstrings.ToLower(_ColorName[0:5]): MyPrefix_Black,", + (string) (len=52) "\t_ColorName[5:10]: MyPrefix_White,", + (string) (len=52) "\tstrings.ToLower(_ColorName[5:10]): MyPrefix_White,", + (string) (len=50) "\t_ColorName[10:13]: MyPrefix_Red,", + (string) (len=50) "\tstrings.ToLower(_ColorName[10:13]): MyPrefix_Red,", + (string) (len=52) "\t_ColorName[13:18]: MyPrefix_Green,", + (string) (len=52) "\tstrings.ToLower(_ColorName[13:18]): MyPrefix_Green,", + (string) (len=51) "\t_ColorName[18:22]: MyPrefix_Blue,", + (string) (len=51) "\tstrings.ToLower(_ColorName[18:22]): MyPrefix_Blue,", + (string) (len=51) "\t_ColorName[22:26]: MyPrefix_Grey,", + (string) (len=51) "\tstrings.ToLower(_ColorName[22:26]): MyPrefix_Grey,", + (string) (len=53) "\t_ColorName[26:32]: MyPrefix_Yellow,", + (string) (len=53) "\tstrings.ToLower(_ColorName[26:32]): MyPrefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseColor attempts to convert a string to a Color.", + (string) (len=45) "func ParseColor(name string) (Color, error) {", + (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Color(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColor)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseColor(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Color) Set(val string) error {", + (string) (len=26) "\tv, err := ParseColor(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Color) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Color) Type() string {", + (string) (len=15) "\treturn \"Color\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=55) "\t// MyPrefix_Black is a ColorWithComment of type Black.", + (string) (len=39) "\tMyPrefix_Black ColorWithComment = iota", + (string) (len=55) "\t// MyPrefix_White is a ColorWithComment of type White.", + (string) (len=15) "\tMyPrefix_White", + (string) (len=51) "\t// MyPrefix_Red is a ColorWithComment of type Red.", + (string) (len=13) "\tMyPrefix_Red", + (string) (len=55) "\t// MyPrefix_Green is a ColorWithComment of type Green.", + (string) (len=15) "\tMyPrefix_Green", + (string) (len=53) "\t// MyPrefix_Blue is a ColorWithComment of type Blue.", + (string) (len=24) "\t// Blue starts with 33.", + (string) (len=43) "\tMyPrefix_Blue ColorWithComment = iota + 29", + (string) (len=53) "\t// MyPrefix_Grey is a ColorWithComment of type Grey.", + (string) (len=14) "\tMyPrefix_Grey", + (string) (len=57) "\t// MyPrefix_Yellow is a ColorWithComment of type Yellow.", + (string) (len=16) "\tMyPrefix_Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=75) "var ErrInvalidColorWithComment = errors.New(\"not a valid ColorWithComment\")", + (string) "", + (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", + (string) (len=45) "\tMyPrefix_Black: _ColorWithCommentName[0:5],", + (string) (len=46) "\tMyPrefix_White: _ColorWithCommentName[5:10],", + (string) (len=47) "\tMyPrefix_Red: _ColorWithCommentName[10:13],", + (string) (len=47) "\tMyPrefix_Green: _ColorWithCommentName[13:18],", + (string) (len=47) "\tMyPrefix_Blue: _ColorWithCommentName[18:22],", + (string) (len=47) "\tMyPrefix_Grey: _ColorWithCommentName[22:26],", + (string) (len=47) "\tMyPrefix_Yellow: _ColorWithCommentName[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=43) "func (x ColorWithComment) String() string {", + (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=42) "func (x ColorWithComment) IsValid() bool {", + (string) (len=33) "\t_, ok := _ColorWithCommentMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", + (string) (len=63) "\t_ColorWithCommentName[0:5]: MyPrefix_Black,", + (string) (len=63) "\tstrings.ToLower(_ColorWithCommentName[0:5]): MyPrefix_Black,", + (string) (len=63) "\t_ColorWithCommentName[5:10]: MyPrefix_White,", + (string) (len=63) "\tstrings.ToLower(_ColorWithCommentName[5:10]): MyPrefix_White,", + (string) (len=61) "\t_ColorWithCommentName[10:13]: MyPrefix_Red,", + (string) (len=61) "\tstrings.ToLower(_ColorWithCommentName[10:13]): MyPrefix_Red,", + (string) (len=63) "\t_ColorWithCommentName[13:18]: MyPrefix_Green,", + (string) (len=63) "\tstrings.ToLower(_ColorWithCommentName[13:18]): MyPrefix_Green,", + (string) (len=62) "\t_ColorWithCommentName[18:22]: MyPrefix_Blue,", + (string) (len=62) "\tstrings.ToLower(_ColorWithCommentName[18:22]): MyPrefix_Blue,", + (string) (len=62) "\t_ColorWithCommentName[22:26]: MyPrefix_Grey,", + (string) (len=62) "\tstrings.ToLower(_ColorWithCommentName[22:26]): MyPrefix_Grey,", + (string) (len=64) "\t_ColorWithCommentName[26:32]: MyPrefix_Yellow,", + (string) (len=64) "\tstrings.ToLower(_ColorWithCommentName[26:32]): MyPrefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=76) "// ParseColorWithComment attempts to convert a string to a ColorWithComment.", + (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", + (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=85) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", + (string) (len=37) "\tv, err := ParseColorWithComment(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=42) "func (x *ColorWithComment) Type() string {", + (string) (len=26) "\treturn \"ColorWithComment\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// MyPrefix_Black is a ColorWithComment2 of type Black.", + (string) (len=40) "\tMyPrefix_Black ColorWithComment2 = iota", + (string) (len=56) "\t// MyPrefix_White is a ColorWithComment2 of type White.", + (string) (len=15) "\tMyPrefix_White", + (string) (len=52) "\t// MyPrefix_Red is a ColorWithComment2 of type Red.", + (string) (len=13) "\tMyPrefix_Red", + (string) (len=56) "\t// MyPrefix_Green is a ColorWithComment2 of type Green.", + (string) (len=15) "\tMyPrefix_Green", + (string) (len=54) "\t// MyPrefix_Blue is a ColorWithComment2 of type Blue.", + (string) (len=23) "\t// Blue starts with 33", + (string) (len=44) "\tMyPrefix_Blue ColorWithComment2 = iota + 29", + (string) (len=54) "\t// MyPrefix_Grey is a ColorWithComment2 of type Grey.", + (string) (len=14) "\tMyPrefix_Grey", + (string) (len=58) "\t// MyPrefix_Yellow is a ColorWithComment2 of type Yellow.", + (string) (len=16) "\tMyPrefix_Yellow", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment2 = errors.New(\"not a valid ColorWithComment2\")", + (string) "", + (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", + (string) "", + (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", + (string) (len=46) "\tMyPrefix_Black: _ColorWithComment2Name[0:5],", + (string) (len=47) "\tMyPrefix_White: _ColorWithComment2Name[5:10],", + (string) (len=48) "\tMyPrefix_Red: _ColorWithComment2Name[10:13],", + (string) (len=48) "\tMyPrefix_Green: _ColorWithComment2Name[13:18],", + (string) (len=48) "\tMyPrefix_Blue: _ColorWithComment2Name[18:22],", + (string) (len=48) "\tMyPrefix_Grey: _ColorWithComment2Name[22:26],", + (string) (len=48) "\tMyPrefix_Yellow: _ColorWithComment2Name[26:32],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment2) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment2) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment2Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", + (string) (len=64) "\t_ColorWithComment2Name[0:5]: MyPrefix_Black,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): MyPrefix_Black,", + (string) (len=64) "\t_ColorWithComment2Name[5:10]: MyPrefix_White,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): MyPrefix_White,", + (string) (len=62) "\t_ColorWithComment2Name[10:13]: MyPrefix_Red,", + (string) (len=62) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): MyPrefix_Red,", + (string) (len=64) "\t_ColorWithComment2Name[13:18]: MyPrefix_Green,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): MyPrefix_Green,", + (string) (len=63) "\t_ColorWithComment2Name[18:22]: MyPrefix_Blue,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): MyPrefix_Blue,", + (string) (len=63) "\t_ColorWithComment2Name[22:26]: MyPrefix_Grey,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): MyPrefix_Grey,", + (string) (len=65) "\t_ColorWithComment2Name[26:32]: MyPrefix_Yellow,", + (string) (len=65) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): MyPrefix_Yellow,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2.", + (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment2)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment2(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment2) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment2\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=56) "\t// MyPrefix_Black is a ColorWithComment3 of type Black.", + (string) (len=40) "\tMyPrefix_Black ColorWithComment3 = iota", + (string) (len=56) "\t// MyPrefix_White is a ColorWithComment3 of type White.", + (string) (len=15) "\tMyPrefix_White", + (string) (len=52) "\t// MyPrefix_Red is a ColorWithComment3 of type Red.", + (string) (len=13) "\tMyPrefix_Red", + (string) (len=56) "\t// MyPrefix_Green is a ColorWithComment3 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=45) "\tMyPrefix_Green ColorWithComment3 = iota + 30", + (string) (len=54) "\t// MyPrefix_Blue is a ColorWithComment3 of type Blue.", + (string) (len=14) "\tMyPrefix_Blue", + (string) (len=54) "\t// MyPrefix_Grey is a ColorWithComment3 of type Grey.", + (string) (len=14) "\tMyPrefix_Grey", + (string) (len=58) "\t// MyPrefix_Yellow is a ColorWithComment3 of type Yellow.", + (string) (len=16) "\tMyPrefix_Yellow", + (string) (len=65) "\t// MyPrefix_BlueGreen is a ColorWithComment3 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=19) "\tMyPrefix_BlueGreen", + (string) (len=65) "\t// MyPrefix_RedOrange is a ColorWithComment3 of type Red-Orange.", + (string) (len=19) "\tMyPrefix_RedOrange", + (string) (len=74) "\t// MyPrefix_RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", + (string) (len=23) "\tMyPrefix_RedOrangeBlue", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment3 = errors.New(\"not a valid ColorWithComment3\")", + (string) "", + (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", + (string) "", + (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", + (string) (len=53) "\tMyPrefix_Black: _ColorWithComment3Name[0:5],", + (string) (len=54) "\tMyPrefix_White: _ColorWithComment3Name[5:10],", + (string) (len=55) "\tMyPrefix_Red: _ColorWithComment3Name[10:13],", + (string) (len=55) "\tMyPrefix_Green: _ColorWithComment3Name[13:18],", + (string) (len=55) "\tMyPrefix_Blue: _ColorWithComment3Name[18:22],", + (string) (len=55) "\tMyPrefix_Grey: _ColorWithComment3Name[22:26],", + (string) (len=55) "\tMyPrefix_Yellow: _ColorWithComment3Name[26:32],", + (string) (len=55) "\tMyPrefix_BlueGreen: _ColorWithComment3Name[32:42],", + (string) (len=55) "\tMyPrefix_RedOrange: _ColorWithComment3Name[42:52],", + (string) (len=55) "\tMyPrefix_RedOrangeBlue: _ColorWithComment3Name[52:67],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment3) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment3) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment3Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", + (string) (len=64) "\t_ColorWithComment3Name[0:5]: MyPrefix_Black,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): MyPrefix_Black,", + (string) (len=64) "\t_ColorWithComment3Name[5:10]: MyPrefix_White,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): MyPrefix_White,", + (string) (len=62) "\t_ColorWithComment3Name[10:13]: MyPrefix_Red,", + (string) (len=62) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): MyPrefix_Red,", + (string) (len=64) "\t_ColorWithComment3Name[13:18]: MyPrefix_Green,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): MyPrefix_Green,", + (string) (len=63) "\t_ColorWithComment3Name[18:22]: MyPrefix_Blue,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): MyPrefix_Blue,", + (string) (len=63) "\t_ColorWithComment3Name[22:26]: MyPrefix_Grey,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): MyPrefix_Grey,", + (string) (len=65) "\t_ColorWithComment3Name[26:32]: MyPrefix_Yellow,", + (string) (len=65) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): MyPrefix_Yellow,", + (string) (len=68) "\t_ColorWithComment3Name[32:42]: MyPrefix_BlueGreen,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): MyPrefix_BlueGreen,", + (string) (len=68) "\t_ColorWithComment3Name[42:52]: MyPrefix_RedOrange,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): MyPrefix_RedOrange,", + (string) (len=72) "\t_ColorWithComment3Name[52:67]: MyPrefix_RedOrangeBlue,", + (string) (len=72) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): MyPrefix_RedOrangeBlue,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3.", + (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment3)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment3(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment3) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment3\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=18) "\t// Skipped value.", + (string) (len=15) "\t// Placeholder", + (string) (len=27) "\t_ ColorWithComment4 = iota", + (string) (len=56) "\t// MyPrefix_Black is a ColorWithComment4 of type Black.", + (string) (len=15) "\tMyPrefix_Black", + (string) (len=56) "\t// MyPrefix_White is a ColorWithComment4 of type White.", + (string) (len=15) "\tMyPrefix_White", + (string) (len=52) "\t// MyPrefix_Red is a ColorWithComment4 of type Red.", + (string) (len=13) "\tMyPrefix_Red", + (string) (len=56) "\t// MyPrefix_Green is a ColorWithComment4 of type Green.", + (string) (len=24) "\t// Green starts with 33", + (string) (len=45) "\tMyPrefix_Green ColorWithComment4 = iota + 29", + (string) (len=54) "\t// MyPrefix_Blue is a ColorWithComment4 of type Blue.", + (string) (len=14) "\tMyPrefix_Blue", + (string) (len=54) "\t// MyPrefix_Grey is a ColorWithComment4 of type Grey.", + (string) (len=14) "\tMyPrefix_Grey", + (string) (len=58) "\t// MyPrefix_Yellow is a ColorWithComment4 of type Yellow.", + (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", + (string) (len=16) "\tMyPrefix_Yellow", + (string) (len=65) "\t// MyPrefix_BlueGreen is a ColorWithComment4 of type Blue-Green.", + (string) (len=22) "\t// blue-green comment", + (string) (len=19) "\tMyPrefix_BlueGreen", + (string) (len=65) "\t// MyPrefix_RedOrange is a ColorWithComment4 of type Red-Orange.", + (string) (len=20) "\t// has a , in it!?!", + (string) (len=19) "\tMyPrefix_RedOrange", + (string) (len=1) ")", + (string) "", + (string) (len=77) "var ErrInvalidColorWithComment4 = errors.New(\"not a valid ColorWithComment4\")", + (string) "", + (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", + (string) "", + (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", + (string) (len=49) "\tMyPrefix_Black: _ColorWithComment4Name[0:5],", + (string) (len=50) "\tMyPrefix_White: _ColorWithComment4Name[5:10],", + (string) (len=51) "\tMyPrefix_Red: _ColorWithComment4Name[10:13],", + (string) (len=51) "\tMyPrefix_Green: _ColorWithComment4Name[13:18],", + (string) (len=51) "\tMyPrefix_Blue: _ColorWithComment4Name[18:22],", + (string) (len=51) "\tMyPrefix_Grey: _ColorWithComment4Name[22:26],", + (string) (len=51) "\tMyPrefix_Yellow: _ColorWithComment4Name[26:32],", + (string) (len=51) "\tMyPrefix_BlueGreen: _ColorWithComment4Name[32:42],", + (string) (len=51) "\tMyPrefix_RedOrange: _ColorWithComment4Name[42:52],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=44) "func (x ColorWithComment4) String() string {", + (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=43) "func (x ColorWithComment4) IsValid() bool {", + (string) (len=34) "\t_, ok := _ColorWithComment4Map[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", + (string) (len=64) "\t_ColorWithComment4Name[0:5]: MyPrefix_Black,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): MyPrefix_Black,", + (string) (len=64) "\t_ColorWithComment4Name[5:10]: MyPrefix_White,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): MyPrefix_White,", + (string) (len=62) "\t_ColorWithComment4Name[10:13]: MyPrefix_Red,", + (string) (len=62) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): MyPrefix_Red,", + (string) (len=64) "\t_ColorWithComment4Name[13:18]: MyPrefix_Green,", + (string) (len=64) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): MyPrefix_Green,", + (string) (len=63) "\t_ColorWithComment4Name[18:22]: MyPrefix_Blue,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): MyPrefix_Blue,", + (string) (len=63) "\t_ColorWithComment4Name[22:26]: MyPrefix_Grey,", + (string) (len=63) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): MyPrefix_Grey,", + (string) (len=65) "\t_ColorWithComment4Name[26:32]: MyPrefix_Yellow,", + (string) (len=65) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): MyPrefix_Yellow,", + (string) (len=68) "\t_ColorWithComment4Name[32:42]: MyPrefix_BlueGreen,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): MyPrefix_BlueGreen,", + (string) (len=68) "\t_ColorWithComment4Name[42:52]: MyPrefix_RedOrange,", + (string) (len=68) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): MyPrefix_RedOrange,", + (string) (len=1) "}", + (string) "", + (string) (len=78) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4.", + (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", + (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=87) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidColorWithComment4)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", + (string) (len=38) "\tv, err := ParseColorWithComment4(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=43) "func (x *ColorWithComment4) Type() string {", + (string) (len=27) "\treturn \"ColorWithComment4\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=52) "\t// MyPrefix_Unknown is a Enum64bit of type Unknown.", + (string) (len=34) "\tMyPrefix_Unknown Enum64bit = iota", + (string) (len=48) "\t// MyPrefix_E2P15 is a Enum64bit of type E2P15.", + (string) (len=40) "\tMyPrefix_E2P15 Enum64bit = iota + 32767", + (string) (len=48) "\t// MyPrefix_E2P16 is a Enum64bit of type E2P16.", + (string) (len=40) "\tMyPrefix_E2P16 Enum64bit = iota + 65534", + (string) (len=48) "\t// MyPrefix_E2P17 is a Enum64bit of type E2P17.", + (string) (len=41) "\tMyPrefix_E2P17 Enum64bit = iota + 131069", + (string) (len=48) "\t// MyPrefix_E2P18 is a Enum64bit of type E2P18.", + (string) (len=41) "\tMyPrefix_E2P18 Enum64bit = iota + 262140", + (string) (len=48) "\t// MyPrefix_E2P19 is a Enum64bit of type E2P19.", + (string) (len=41) "\tMyPrefix_E2P19 Enum64bit = iota + 524283", + (string) (len=48) "\t// MyPrefix_E2P20 is a Enum64bit of type E2P20.", + (string) (len=42) "\tMyPrefix_E2P20 Enum64bit = iota + 1048570", + (string) (len=48) "\t// MyPrefix_E2P21 is a Enum64bit of type E2P21.", + (string) (len=42) "\tMyPrefix_E2P21 Enum64bit = iota + 2097145", + (string) (len=48) "\t// MyPrefix_E2P22 is a Enum64bit of type E2P22.", + (string) (len=43) "\tMyPrefix_E2P22 Enum64bit = iota + 33554424", + (string) (len=48) "\t// MyPrefix_E2P23 is a Enum64bit of type E2P23.", + (string) (len=43) "\tMyPrefix_E2P23 Enum64bit = iota + 67108855", + (string) (len=48) "\t// MyPrefix_E2P28 is a Enum64bit of type E2P28.", + (string) (len=44) "\tMyPrefix_E2P28 Enum64bit = iota + 536870902", + (string) (len=48) "\t// MyPrefix_E2P30 is a Enum64bit of type E2P30.", + (string) (len=45) "\tMyPrefix_E2P30 Enum64bit = iota + 1073741813", + (string) (len=48) "\t// MyPrefix_E2P31 is a Enum64bit of type E2P31.", + (string) (len=45) "\tMyPrefix_E2P31 Enum64bit = iota + 2147483636", + (string) (len=48) "\t// MyPrefix_E2P32 is a Enum64bit of type E2P32.", + (string) (len=45) "\tMyPrefix_E2P32 Enum64bit = iota + 4294967283", + (string) (len=48) "\t// MyPrefix_E2P33 is a Enum64bit of type E2P33.", + (string) (len=45) "\tMyPrefix_E2P33 Enum64bit = iota + 8454967282", + (string) (len=1) ")", + (string) "", + (string) (len=61) "var ErrInvalidEnum64bit = errors.New(\"not a valid Enum64bit\")", + (string) "", + (string) (len=102) "const _Enum64bitName = \"UnknownE2P15E2P16E2P17E2P18E2P19E2P20E2P21E2P22E2P23E2P28E2P30E2P31E2P32E2P33\"", + (string) "", + (string) (len=41) "var _Enum64bitMap = map[Enum64bit]string{", + (string) (len=39) "\tMyPrefix_Unknown: _Enum64bitName[0:7],", + (string) (len=40) "\tMyPrefix_E2P15: _Enum64bitName[7:12],", + (string) (len=41) "\tMyPrefix_E2P16: _Enum64bitName[12:17],", + (string) (len=41) "\tMyPrefix_E2P17: _Enum64bitName[17:22],", + (string) (len=41) "\tMyPrefix_E2P18: _Enum64bitName[22:27],", + (string) (len=41) "\tMyPrefix_E2P19: _Enum64bitName[27:32],", + (string) (len=41) "\tMyPrefix_E2P20: _Enum64bitName[32:37],", + (string) (len=41) "\tMyPrefix_E2P21: _Enum64bitName[37:42],", + (string) (len=41) "\tMyPrefix_E2P22: _Enum64bitName[42:47],", + (string) (len=41) "\tMyPrefix_E2P23: _Enum64bitName[47:52],", + (string) (len=41) "\tMyPrefix_E2P28: _Enum64bitName[52:57],", + (string) (len=41) "\tMyPrefix_E2P30: _Enum64bitName[57:62],", + (string) (len=41) "\tMyPrefix_E2P31: _Enum64bitName[62:67],", + (string) (len=41) "\tMyPrefix_E2P32: _Enum64bitName[67:72],", + (string) (len=41) "\tMyPrefix_E2P33: _Enum64bitName[72:77],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=36) "func (x Enum64bit) String() string {", + (string) (len=37) "\tif str, ok := _Enum64bitMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=39) "\treturn fmt.Sprintf(\"Enum64bit(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=35) "func (x Enum64bit) IsValid() bool {", + (string) (len=26) "\t_, ok := _Enum64bitMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=43) "var _Enum64bitValue = map[string]Enum64bit{", + (string) (len=58) "\t_Enum64bitName[0:7]: MyPrefix_Unknown,", + (string) (len=58) "\tstrings.ToLower(_Enum64bitName[0:7]): MyPrefix_Unknown,", + (string) (len=56) "\t_Enum64bitName[7:12]: MyPrefix_E2P15,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[7:12]): MyPrefix_E2P15,", + (string) (len=56) "\t_Enum64bitName[12:17]: MyPrefix_E2P16,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[12:17]): MyPrefix_E2P16,", + (string) (len=56) "\t_Enum64bitName[17:22]: MyPrefix_E2P17,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[17:22]): MyPrefix_E2P17,", + (string) (len=56) "\t_Enum64bitName[22:27]: MyPrefix_E2P18,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[22:27]): MyPrefix_E2P18,", + (string) (len=56) "\t_Enum64bitName[27:32]: MyPrefix_E2P19,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[27:32]): MyPrefix_E2P19,", + (string) (len=56) "\t_Enum64bitName[32:37]: MyPrefix_E2P20,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[32:37]): MyPrefix_E2P20,", + (string) (len=56) "\t_Enum64bitName[37:42]: MyPrefix_E2P21,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[37:42]): MyPrefix_E2P21,", + (string) (len=56) "\t_Enum64bitName[42:47]: MyPrefix_E2P22,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[42:47]): MyPrefix_E2P22,", + (string) (len=56) "\t_Enum64bitName[47:52]: MyPrefix_E2P23,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[47:52]): MyPrefix_E2P23,", + (string) (len=56) "\t_Enum64bitName[52:57]: MyPrefix_E2P28,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[52:57]): MyPrefix_E2P28,", + (string) (len=56) "\t_Enum64bitName[57:62]: MyPrefix_E2P30,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[57:62]): MyPrefix_E2P30,", + (string) (len=56) "\t_Enum64bitName[62:67]: MyPrefix_E2P31,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[62:67]): MyPrefix_E2P31,", + (string) (len=56) "\t_Enum64bitName[67:72]: MyPrefix_E2P32,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[67:72]): MyPrefix_E2P32,", + (string) (len=56) "\t_Enum64bitName[72:77]: MyPrefix_E2P33,", + (string) (len=56) "\tstrings.ToLower(_Enum64bitName[72:77]): MyPrefix_E2P33,", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// ParseEnum64bit attempts to convert a string to a Enum64bit.", + (string) (len=53) "func ParseEnum64bit(name string) (Enum64bit, error) {", + (string) (len=40) "\tif x, ok := _Enum64bitValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=71) "\treturn Enum64bit(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidEnum64bit)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=50) "func (x Enum64bit) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=54) "func (x *Enum64bit) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=33) "\ttmp, err := ParseEnum64bit(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=43) "func (x *Enum64bit) Set(val string) error {", + (string) (len=30) "\tv, err := ParseEnum64bit(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=39) "func (x *Enum64bit) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=35) "func (x *Enum64bit) Type() string {", + (string) (len=19) "\treturn \"Enum64bit\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=46) "\t// MyPrefix_Toyota is a Model of type Toyota.", + (string) (len=29) "\tMyPrefix_Toyota Model = iota", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=44) "\t// MyPrefix_Chevy is a Model of type Chevy.", + (string) (len=15) "\tMyPrefix_Chevy", + (string) (len=18) "\t// Skipped value.", + (string) (len=2) "\t_", + (string) (len=42) "\t// MyPrefix_Ford is a Model of type Ford.", + (string) (len=14) "\tMyPrefix_Ford", + (string) (len=1) ")", + (string) "", + (string) (len=53) "var ErrInvalidModel = errors.New(\"not a valid Model\")", + (string) "", + (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", + (string) "", + (string) (len=33) "var _ModelMap = map[Model]string{", + (string) (len=34) "\tMyPrefix_Toyota: _ModelName[0:6],", + (string) (len=35) "\tMyPrefix_Chevy: _ModelName[6:11],", + (string) (len=36) "\tMyPrefix_Ford: _ModelName[11:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=32) "func (x Model) String() string {", + (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=31) "func (x Model) IsValid() bool {", + (string) (len=22) "\t_, ok := _ModelMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=35) "var _ModelValue = map[string]Model{", + (string) (len=53) "\t_ModelName[0:6]: MyPrefix_Toyota,", + (string) (len=53) "\tstrings.ToLower(_ModelName[0:6]): MyPrefix_Toyota,", + (string) (len=52) "\t_ModelName[6:11]: MyPrefix_Chevy,", + (string) (len=52) "\tstrings.ToLower(_ModelName[6:11]): MyPrefix_Chevy,", + (string) (len=51) "\t_ModelName[11:15]: MyPrefix_Ford,", + (string) (len=51) "\tstrings.ToLower(_ModelName[11:15]): MyPrefix_Ford,", + (string) (len=1) "}", + (string) "", + (string) (len=54) "// ParseModel attempts to convert a string to a Model.", + (string) (len=45) "func ParseModel(name string) (Model, error) {", + (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=63) "\treturn Model(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidModel)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=29) "\ttmp, err := ParseModel(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=39) "func (x *Model) Set(val string) error {", + (string) (len=26) "\tv, err := ParseModel(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=35) "func (x *Model) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=31) "func (x *Model) Type() string {", + (string) (len=15) "\treturn \"Model\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=61) "\t// MyPrefix_Продам is a NonASCII of type Продам.", + (string) (len=45) "\tMyPrefix_Продам NonASCII = iota + 1114", + (string) (len=49) "\t// MyPrefix_車庫 is a NonASCII of type 車庫.", + (string) (len=38) "\tMyPrefix_車庫 NonASCII = iota + 299", + (string) (len=53) "\t// MyPrefix_Էժան is a NonASCII of type Էժան.", + (string) (len=39) "\tMyPrefix_Էժան NonASCII = iota + -1", + (string) (len=1) ")", + (string) "", + (string) (len=59) "var ErrInvalidNonASCII = errors.New(\"not a valid NonASCII\")", + (string) "", + (string) (len=50) "const _NonASCIIName = \"Продам車庫էժան\"", + (string) "", + (string) (len=39) "var _NonASCIIMap = map[NonASCII]string{", + (string) (len=44) "\tMyPrefix_Продам: _NonASCIIName[0:12],", + (string) (len=43) "\tMyPrefix_車庫: _NonASCIIName[12:18],", + (string) (len=43) "\tMyPrefix_Էժան: _NonASCIIName[18:26],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=35) "func (x NonASCII) String() string {", + (string) (len=36) "\tif str, ok := _NonASCIIMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=38) "\treturn fmt.Sprintf(\"NonASCII(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=34) "func (x NonASCII) IsValid() bool {", + (string) (len=25) "\t_, ok := _NonASCIIMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=41) "var _NonASCIIValue = map[string]NonASCII{", + (string) (len=62) "\t_NonASCIIName[0:12]: MyPrefix_Продам,", + (string) (len=62) "\tstrings.ToLower(_NonASCIIName[0:12]): MyPrefix_Продам,", + (string) (len=56) "\t_NonASCIIName[12:18]: MyPrefix_車庫,", + (string) (len=56) "\tstrings.ToLower(_NonASCIIName[12:18]): MyPrefix_車庫,", + (string) (len=58) "\t_NonASCIIName[18:26]: MyPrefix_Էժան,", + (string) (len=58) "\tstrings.ToLower(_NonASCIIName[18:26]): MyPrefix_Էժան,", + (string) (len=1) "}", + (string) "", + (string) (len=60) "// ParseNonASCII attempts to convert a string to a NonASCII.", + (string) (len=51) "func ParseNonASCII(name string) (NonASCII, error) {", + (string) (len=39) "\tif x, ok := _NonASCIIValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=69) "\treturn NonASCII(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidNonASCII)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=49) "func (x NonASCII) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=53) "func (x *NonASCII) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=32) "\ttmp, err := ParseNonASCII(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=42) "func (x *NonASCII) Set(val string) error {", + (string) (len=29) "\tv, err := ParseNonASCII(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=38) "func (x *NonASCII) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=34) "func (x *NonASCII) Type() string {", + (string) (len=18) "\treturn \"NonASCII\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=60) "\t// MyPrefix_TestHyphen is a Sanitizing of type Test-Hyphen.", + (string) (len=38) "\tMyPrefix_TestHyphen Sanitizing = iota", + (string) (len=62) "\t// MyPrefix_HyphenStart is a Sanitizing of type -HyphenStart.", + (string) (len=21) "\tMyPrefix_HyphenStart", + (string) (len=71) "\t// MyPrefix__UnderscoreFirst is a Sanitizing of type _UnderscoreFirst.", + (string) (len=26) "\tMyPrefix__UnderscoreFirst", + (string) (len=63) "\t// MyPrefix_0NumberFirst is a Sanitizing of type 0NumberFirst.", + (string) (len=22) "\tMyPrefix_0NumberFirst", + (string) (len=59) "\t// MyPrefix_123456789A is a Sanitizing of type 123456789A.", + (string) (len=20) "\tMyPrefix_123456789A", + (string) (len=60) "\t// MyPrefix_123123Asdf is a Sanitizing of type 123123-Asdf.", + (string) (len=20) "\tMyPrefix_123123Asdf", + (string) (len=65) "\t// MyPrefix_EndingHyphen is a Sanitizing of type Ending-Hyphen-.", + (string) (len=22) "\tMyPrefix_EndingHyphen", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidSanitizing = errors.New(\"not a valid Sanitizing\")", + (string) "", + (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", + (string) "", + (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", + (string) (len=50) "\tMyPrefix_TestHyphen: _SanitizingName[0:11],", + (string) (len=51) "\tMyPrefix_HyphenStart: _SanitizingName[11:23],", + (string) (len=51) "\tMyPrefix__UnderscoreFirst: _SanitizingName[23:39],", + (string) (len=51) "\tMyPrefix_0NumberFirst: _SanitizingName[39:51],", + (string) (len=51) "\tMyPrefix_123456789A: _SanitizingName[51:61],", + (string) (len=51) "\tMyPrefix_123123Asdf: _SanitizingName[61:72],", + (string) (len=51) "\tMyPrefix_EndingHyphen: _SanitizingName[72:86],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x Sanitizing) String() string {", + (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x Sanitizing) IsValid() bool {", + (string) (len=27) "\t_, ok := _SanitizingMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", + (string) (len=62) "\t_SanitizingName[0:11]: MyPrefix_TestHyphen,", + (string) (len=62) "\tstrings.ToLower(_SanitizingName[0:11]): MyPrefix_TestHyphen,", + (string) (len=63) "\t_SanitizingName[11:23]: MyPrefix_HyphenStart,", + (string) (len=63) "\tstrings.ToLower(_SanitizingName[11:23]): MyPrefix_HyphenStart,", + (string) (len=68) "\t_SanitizingName[23:39]: MyPrefix__UnderscoreFirst,", + (string) (len=68) "\tstrings.ToLower(_SanitizingName[23:39]): MyPrefix__UnderscoreFirst,", + (string) (len=64) "\t_SanitizingName[39:51]: MyPrefix_0NumberFirst,", + (string) (len=64) "\tstrings.ToLower(_SanitizingName[39:51]): MyPrefix_0NumberFirst,", + (string) (len=62) "\t_SanitizingName[51:61]: MyPrefix_123456789A,", + (string) (len=62) "\tstrings.ToLower(_SanitizingName[51:61]): MyPrefix_123456789A,", + (string) (len=62) "\t_SanitizingName[61:72]: MyPrefix_123123Asdf,", + (string) (len=62) "\tstrings.ToLower(_SanitizingName[61:72]): MyPrefix_123123Asdf,", + (string) (len=64) "\t_SanitizingName[72:86]: MyPrefix_EndingHyphen,", + (string) (len=64) "\tstrings.ToLower(_SanitizingName[72:86]): MyPrefix_EndingHyphen,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseSanitizing attempts to convert a string to a Sanitizing.", + (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", + (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=73) "\treturn Sanitizing(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSanitizing)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=34) "\ttmp, err := ParseSanitizing(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *Sanitizing) Set(val string) error {", + (string) (len=31) "\tv, err := ParseSanitizing(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *Sanitizing) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *Sanitizing) Type() string {", + (string) (len=20) "\treturn \"Sanitizing\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=41) "\t// MyPrefix_Coke is a Soda of type Coke.", + (string) (len=26) "\tMyPrefix_Coke Soda = iota", + (string) (len=43) "\t// MyPrefix_Pepsi is a Soda of type Pepsi.", + (string) (len=15) "\tMyPrefix_Pepsi", + (string) (len=45) "\t// MyPrefix_MtnDew is a Soda of type MtnDew.", + (string) (len=16) "\tMyPrefix_MtnDew", + (string) (len=1) ")", + (string) "", + (string) (len=51) "var ErrInvalidSoda = errors.New(\"not a valid Soda\")", + (string) "", + (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", + (string) "", + (string) (len=31) "var _SodaMap = map[Soda]string{", + (string) (len=33) "\tMyPrefix_Coke: _SodaName[0:4],", + (string) (len=33) "\tMyPrefix_Pepsi: _SodaName[4:9],", + (string) (len=34) "\tMyPrefix_MtnDew: _SodaName[9:15],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=31) "func (x Soda) String() string {", + (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=30) "func (x Soda) IsValid() bool {", + (string) (len=21) "\t_, ok := _SodaMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=33) "var _SodaValue = map[string]Soda{", + (string) (len=49) "\t_SodaName[0:4]: MyPrefix_Coke,", + (string) (len=49) "\tstrings.ToLower(_SodaName[0:4]): MyPrefix_Coke,", + (string) (len=50) "\t_SodaName[4:9]: MyPrefix_Pepsi,", + (string) (len=50) "\tstrings.ToLower(_SodaName[4:9]): MyPrefix_Pepsi,", + (string) (len=51) "\t_SodaName[9:15]: MyPrefix_MtnDew,", + (string) (len=51) "\tstrings.ToLower(_SodaName[9:15]): MyPrefix_MtnDew,", + (string) (len=1) "}", + (string) "", + (string) (len=52) "// ParseSoda attempts to convert a string to a Soda.", + (string) (len=43) "func ParseSoda(name string) (Soda, error) {", + (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=61) "\treturn Soda(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidSoda)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=28) "\ttmp, err := ParseSoda(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=38) "func (x *Soda) Set(val string) error {", + (string) (len=25) "\tv, err := ParseSoda(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=34) "func (x *Soda) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=30) "func (x *Soda) Type() string {", + (string) (len=14) "\treturn \"Soda\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=65) "\t// MyPrefix_StartWithNum is a StartNotZero of type StartWithNum.", + (string) (len=47) "\tMyPrefix_StartWithNum StartNotZero = iota + 23", + (string) (len=55) "\t// MyPrefix_NextNum is a StartNotZero of type NextNum.", + (string) (len=17) "\tMyPrefix_NextNum", + (string) (len=1) ")", + (string) "", + (string) (len=67) "var ErrInvalidStartNotZero = errors.New(\"not a valid StartNotZero\")", + (string) "", + (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", + (string) "", + (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", + (string) (len=48) "\tMyPrefix_StartWithNum: _StartNotZeroName[0:12],", + (string) (len=49) "\tMyPrefix_NextNum: _StartNotZeroName[12:19],", + (string) (len=1) "}", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=39) "func (x StartNotZero) String() string {", + (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", + (string) (len=12) "\t\treturn str", + (string) (len=2) "\t}", + (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=38) "func (x StartNotZero) IsValid() bool {", + (string) (len=29) "\t_, ok := _StartNotZeroMap[x]", + (string) (len=10) "\treturn ok", + (string) (len=1) "}", + (string) "", + (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", + (string) (len=66) "\t_StartNotZeroName[0:12]: MyPrefix_StartWithNum,", + (string) (len=66) "\tstrings.ToLower(_StartNotZeroName[0:12]): MyPrefix_StartWithNum,", + (string) (len=61) "\t_StartNotZeroName[12:19]: MyPrefix_NextNum,", + (string) (len=61) "\tstrings.ToLower(_StartNotZeroName[12:19]): MyPrefix_NextNum,", + (string) (len=1) "}", + (string) "", + (string) (len=68) "// ParseStartNotZero attempts to convert a string to a StartNotZero.", + (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", + (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=77) "\treturn StartNotZero(0), fmt.Errorf(\"%s is %w\", name, ErrInvalidStartNotZero)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", + (string) (len=31) "\treturn []byte(x.String()), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", + (string) (len=21) "\tname := string(text)", + (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=46) "func (x *StartNotZero) Set(val string) error {", + (string) (len=33) "\tv, err := ParseStartNotZero(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=42) "func (x *StartNotZero) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=38) "func (x *StartNotZero) Type() string {", + (string) (len=22) "\treturn \"StartNotZero\"", + (string) (len=1) "}", + (string) "", + (string) (len=7) "const (", + (string) (len=51) "\t// MyPrefix_Random is a StringEnum of type random.", + (string) (len=38) "\tMyPrefix_Random StringEnum = \"random\"", + (string) (len=51) "\t// MyPrefix_Values is a StringEnum of type values.", + (string) (len=38) "\tMyPrefix_Values StringEnum = \"values\"", + (string) (len=47) "\t// MyPrefix_Here is a StringEnum of type here.", + (string) (len=34) "\tMyPrefix_Here StringEnum = \"here\"", + (string) (len=1) ")", + (string) "", + (string) (len=63) "var ErrInvalidStringEnum = errors.New(\"not a valid StringEnum\")", + (string) "", + (string) (len=44) "// String implements the Stringer interface.", + (string) (len=37) "func (x StringEnum) String() string {", + (string) (len=17) "\treturn string(x)", + (string) (len=1) "}", + (string) "", + (string) (len=66) "// IsValid provides a quick way to determine if the typed value is", + (string) (len=40) "// part of the allowed enumerated values", + (string) (len=36) "func (x StringEnum) IsValid() bool {", + (string) (len=37) "\t_, err := ParseStringEnum(string(x))", + (string) (len=18) "\treturn err == nil", + (string) (len=1) "}", + (string) "", + (string) (len=45) "var _StringEnumValue = map[string]StringEnum{", + (string) (len=27) "\t\"random\": MyPrefix_Random,", + (string) (len=27) "\t\"values\": MyPrefix_Values,", + (string) (len=25) "\t\"here\": MyPrefix_Here,", + (string) (len=1) "}", + (string) "", + (string) (len=64) "// ParseStringEnum attempts to convert a string to a StringEnum.", + (string) (len=55) "func ParseStringEnum(name string) (StringEnum, error) {", + (string) (len=41) "\tif x, ok := _StringEnumValue[name]; ok {", + (string) (len=15) "\t\treturn x, nil", + (string) (len=2) "\t}", + (string) (len=74) "\treturn StringEnum(\"\"), fmt.Errorf(\"%s is %w\", name, ErrInvalidStringEnum)", + (string) (len=1) "}", + (string) "", + (string) (len=53) "// MarshalText implements the text marshaller method.", + (string) (len=51) "func (x StringEnum) MarshalText() ([]byte, error) {", + (string) (len=30) "\treturn []byte(string(x)), nil", + (string) (len=1) "}", + (string) "", + (string) (len=57) "// UnmarshalText implements the text unmarshaller method.", + (string) (len=55) "func (x *StringEnum) UnmarshalText(text []byte) error {", + (string) (len=42) "\ttmp, err := ParseStringEnum(string(text))", + (string) (len=16) "\tif err != nil {", + (string) (len=12) "\t\treturn err", + (string) (len=2) "\t}", + (string) (len=9) "\t*x = tmp", + (string) (len=11) "\treturn nil", + (string) (len=1) "}", + (string) "", + (string) (len=55) "// Set implements the Golang flag.Value interface func.", + (string) (len=44) "func (x *StringEnum) Set(val string) error {", + (string) (len=31) "\tv, err := ParseStringEnum(val)", + (string) (len=7) "\t*x = v", + (string) (len=11) "\treturn err", + (string) (len=1) "}", + (string) "", + (string) (len=56) "// Get implements the Golang flag.Getter interface func.", + (string) (len=40) "func (x *StringEnum) Get() interface{} {", + (string) (len=10) "\treturn *x", + (string) (len=1) "}", + (string) "", + (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", + (string) (len=36) "func (x *StringEnum) Type() string {", + (string) (len=20) "\treturn \"StringEnum\"", + (string) (len=1) "}", + (string) "" +} diff --git a/generator/.snapshots/generator-TestNoPrefixExampleFile b/generator/.snapshots/generator-TestNoPrefixExampleFile deleted file mode 100644 index 8215e315..00000000 --- a/generator/.snapshots/generator-TestNoPrefixExampleFile +++ /dev/null @@ -1,992 +0,0 @@ -([]string) (len=990) { - (string) (len=28) "// Code generated by go-enum", - (string) (len=15) "// DO NOT EDIT!", - (string) "", - (string) (len=17) "package generator", - (string) "", - (string) (len=8) "import (", - (string) (len=6) "\t\"fmt\"", - (string) (len=10) "\t\"strings\"", - (string) (len=1) ")", - (string) "", - (string) (len=7) "const (", - (string) (len=32) "\t// Cat is a Animal of type Cat.", - (string) (len=18) "\tCat Animal = iota", - (string) (len=32) "\t// Dog is a Animal of type Dog.", - (string) (len=4) "\tDog", - (string) (len=34) "\t// Fish is a Animal of type Fish.", - (string) (len=5) "\tFish", - (string) (len=1) ")", - (string) "", - (string) (len=32) "const _AnimalName = \"CatDogFish\"", - (string) "", - (string) (len=35) "var _AnimalMap = map[Animal]string{", - (string) (len=21) "\t0: _AnimalName[0:3],", - (string) (len=21) "\t1: _AnimalName[3:6],", - (string) (len=22) "\t2: _AnimalName[6:10],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=33) "func (x Animal) String() string {", - (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=37) "var _AnimalValue = map[string]Animal{", - (string) (len=39) "\t_AnimalName[0:3]: 0,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[0:3]): 0,", - (string) (len=39) "\t_AnimalName[3:6]: 1,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[3:6]): 1,", - (string) (len=39) "\t_AnimalName[6:10]: 2,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[6:10]): 2,", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// ParseAnimal attempts to convert a string to a Animal", - (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", - (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=63) "\treturn Animal(0), fmt.Errorf(\"%s is not a valid Animal\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=30) "\ttmp, err := ParseAnimal(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=40) "func (x *Animal) Set(val string) error {", - (string) (len=27) "\tv, err := ParseAnimal(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=36) "func (x *Animal) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=32) "func (x *Animal) Type() string {", - (string) (len=16) "\treturn \"Animal\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=45) "\t// Test_lower is a Cases of type Test_lower.", - (string) (len=24) "\tTest_lower Cases = iota", - (string) (len=49) "\t// Test_capital is a Cases of type Test_capital.", - (string) (len=13) "\tTest_capital", - (string) (len=67) "\t// AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", - (string) (len=22) "\tAnotherLowerCaseStart", - (string) (len=1) ")", - (string) "", - (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", - (string) "", - (string) (len=33) "var _CasesMap = map[Cases]string{", - (string) (len=21) "\t0: _CasesName[0:10],", - (string) (len=22) "\t1: _CasesName[10:22],", - (string) (len=22) "\t2: _CasesName[22:43],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=32) "func (x Cases) String() string {", - (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=35) "var _CasesValue = map[string]Cases{", - (string) (len=39) "\t_CasesName[0:10]: 0,", - (string) (len=39) "\tstrings.ToLower(_CasesName[0:10]): 0,", - (string) (len=39) "\t_CasesName[10:22]: 1,", - (string) (len=39) "\tstrings.ToLower(_CasesName[10:22]): 1,", - (string) (len=39) "\t_CasesName[22:43]: 2,", - (string) (len=39) "\tstrings.ToLower(_CasesName[22:43]): 2,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseCases attempts to convert a string to a Cases", - (string) (len=45) "func ParseCases(name string) (Cases, error) {", - (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=61) "\treturn Cases(0), fmt.Errorf(\"%s is not a valid Cases\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=29) "\ttmp, err := ParseCases(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=39) "func (x *Cases) Set(val string) error {", - (string) (len=26) "\tv, err := ParseCases(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=35) "func (x *Cases) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=31) "func (x *Cases) Type() string {", - (string) (len=15) "\treturn \"Cases\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=35) "\t// Black is a Color of type Black.", - (string) (len=19) "\tBlack Color = iota", - (string) (len=35) "\t// White is a Color of type White.", - (string) (len=6) "\tWhite", - (string) (len=31) "\t// Red is a Color of type Red.", - (string) (len=4) "\tRed", - (string) (len=35) "\t// Green is a Color of type Green.", - (string) (len=6) "\tGreen", - (string) (len=33) "\t// Blue is a Color of type Blue.", - (string) (len=23) "\tBlue Color = iota + 29", - (string) (len=33) "\t// Grey is a Color of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=37) "\t// Yellow is a Color of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=1) ")", - (string) "", - (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", - (string) "", - (string) (len=33) "var _ColorMap = map[Color]string{", - (string) (len=21) "\t0: _ColorName[0:5],", - (string) (len=22) "\t1: _ColorName[5:10],", - (string) (len=23) "\t2: _ColorName[10:13],", - (string) (len=23) "\t3: _ColorName[13:18],", - (string) (len=23) "\t33: _ColorName[18:22],", - (string) (len=23) "\t34: _ColorName[22:26],", - (string) (len=23) "\t35: _ColorName[26:32],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=32) "func (x Color) String() string {", - (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=35) "var _ColorValue = map[string]Color{", - (string) (len=39) "\t_ColorName[0:5]: 0,", - (string) (len=39) "\tstrings.ToLower(_ColorName[0:5]): 0,", - (string) (len=39) "\t_ColorName[5:10]: 1,", - (string) (len=39) "\tstrings.ToLower(_ColorName[5:10]): 1,", - (string) (len=39) "\t_ColorName[10:13]: 2,", - (string) (len=39) "\tstrings.ToLower(_ColorName[10:13]): 2,", - (string) (len=39) "\t_ColorName[13:18]: 3,", - (string) (len=39) "\tstrings.ToLower(_ColorName[13:18]): 3,", - (string) (len=40) "\t_ColorName[18:22]: 33,", - (string) (len=40) "\tstrings.ToLower(_ColorName[18:22]): 33,", - (string) (len=40) "\t_ColorName[22:26]: 34,", - (string) (len=40) "\tstrings.ToLower(_ColorName[22:26]): 34,", - (string) (len=40) "\t_ColorName[26:32]: 35,", - (string) (len=40) "\tstrings.ToLower(_ColorName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseColor attempts to convert a string to a Color", - (string) (len=45) "func ParseColor(name string) (Color, error) {", - (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=61) "\treturn Color(0), fmt.Errorf(\"%s is not a valid Color\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=29) "\ttmp, err := ParseColor(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=39) "func (x *Color) Set(val string) error {", - (string) (len=26) "\tv, err := ParseColor(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=35) "func (x *Color) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=31) "func (x *Color) Type() string {", - (string) (len=15) "\treturn \"Color\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=46) "\t// Black is a ColorWithComment of type Black.", - (string) (len=30) "\tBlack ColorWithComment = iota", - (string) (len=46) "\t// White is a ColorWithComment of type White.", - (string) (len=6) "\tWhite", - (string) (len=42) "\t// Red is a ColorWithComment of type Red.", - (string) (len=4) "\tRed", - (string) (len=46) "\t// Green is a ColorWithComment of type Green.", - (string) (len=6) "\tGreen", - (string) (len=44) "\t// Blue is a ColorWithComment of type Blue.", - (string) (len=23) "\t// Blue starts with 33", - (string) (len=34) "\tBlue ColorWithComment = iota + 29", - (string) (len=44) "\t// Grey is a ColorWithComment of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=48) "\t// Yellow is a ColorWithComment of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=1) ")", - (string) "", - (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", - (string) "", - (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", - (string) (len=32) "\t0: _ColorWithCommentName[0:5],", - (string) (len=33) "\t1: _ColorWithCommentName[5:10],", - (string) (len=34) "\t2: _ColorWithCommentName[10:13],", - (string) (len=34) "\t3: _ColorWithCommentName[13:18],", - (string) (len=34) "\t33: _ColorWithCommentName[18:22],", - (string) (len=34) "\t34: _ColorWithCommentName[22:26],", - (string) (len=34) "\t35: _ColorWithCommentName[26:32],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=43) "func (x ColorWithComment) String() string {", - (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", - (string) (len=50) "\t_ColorWithCommentName[0:5]: 0,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[0:5]): 0,", - (string) (len=50) "\t_ColorWithCommentName[5:10]: 1,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[5:10]): 1,", - (string) (len=50) "\t_ColorWithCommentName[10:13]: 2,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[10:13]): 2,", - (string) (len=50) "\t_ColorWithCommentName[13:18]: 3,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[13:18]): 3,", - (string) (len=51) "\t_ColorWithCommentName[18:22]: 33,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[18:22]): 33,", - (string) (len=51) "\t_ColorWithCommentName[22:26]: 34,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[22:26]): 34,", - (string) (len=51) "\t_ColorWithCommentName[26:32]: 35,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=75) "// ParseColorWithComment attempts to convert a string to a ColorWithComment", - (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", - (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=83) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is not a valid ColorWithComment\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", - (string) (len=37) "\tv, err := ParseColorWithComment(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=42) "func (x *ColorWithComment) Type() string {", - (string) (len=26) "\treturn \"ColorWithComment\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=47) "\t// Black is a ColorWithComment2 of type Black.", - (string) (len=31) "\tBlack ColorWithComment2 = iota", - (string) (len=47) "\t// White is a ColorWithComment2 of type White.", - (string) (len=6) "\tWhite", - (string) (len=43) "\t// Red is a ColorWithComment2 of type Red.", - (string) (len=4) "\tRed", - (string) (len=47) "\t// Green is a ColorWithComment2 of type Green.", - (string) (len=6) "\tGreen", - (string) (len=45) "\t// Blue is a ColorWithComment2 of type Blue.", - (string) (len=23) "\t// Blue starts with 33", - (string) (len=35) "\tBlue ColorWithComment2 = iota + 29", - (string) (len=45) "\t// Grey is a ColorWithComment2 of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=49) "\t// Yellow is a ColorWithComment2 of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=1) ")", - (string) "", - (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", - (string) "", - (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", - (string) (len=33) "\t0: _ColorWithComment2Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment2Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment2Name[10:13],", - (string) (len=35) "\t3: _ColorWithComment2Name[13:18],", - (string) (len=35) "\t33: _ColorWithComment2Name[18:22],", - (string) (len=35) "\t34: _ColorWithComment2Name[22:26],", - (string) (len=35) "\t35: _ColorWithComment2Name[26:32],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=44) "func (x ColorWithComment2) String() string {", - (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", - (string) (len=51) "\t_ColorWithComment2Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment2Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment2Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): 2,", - (string) (len=51) "\t_ColorWithComment2Name[13:18]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): 3,", - (string) (len=52) "\t_ColorWithComment2Name[18:22]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): 33,", - (string) (len=52) "\t_ColorWithComment2Name[22:26]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): 34,", - (string) (len=52) "\t_ColorWithComment2Name[26:32]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2", - (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", - (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is not a valid ColorWithComment2\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", - (string) (len=38) "\tv, err := ParseColorWithComment2(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=43) "func (x *ColorWithComment2) Type() string {", - (string) (len=27) "\treturn \"ColorWithComment2\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=47) "\t// Black is a ColorWithComment3 of type Black.", - (string) (len=31) "\tBlack ColorWithComment3 = iota", - (string) (len=47) "\t// White is a ColorWithComment3 of type White.", - (string) (len=6) "\tWhite", - (string) (len=43) "\t// Red is a ColorWithComment3 of type Red.", - (string) (len=4) "\tRed", - (string) (len=47) "\t// Green is a ColorWithComment3 of type Green.", - (string) (len=24) "\t// Green starts with 33", - (string) (len=36) "\tGreen ColorWithComment3 = iota + 30", - (string) (len=45) "\t// Blue is a ColorWithComment3 of type Blue.", - (string) (len=5) "\tBlue", - (string) (len=45) "\t// Grey is a ColorWithComment3 of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=49) "\t// Yellow is a ColorWithComment3 of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=56) "\t// BlueGreen is a ColorWithComment3 of type Blue-Green.", - (string) (len=22) "\t// blue-green comment", - (string) (len=10) "\tBlueGreen", - (string) (len=56) "\t// RedOrange is a ColorWithComment3 of type Red-Orange.", - (string) (len=10) "\tRedOrange", - (string) (len=65) "\t// RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", - (string) (len=14) "\tRedOrangeBlue", - (string) (len=1) ")", - (string) "", - (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", - (string) "", - (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", - (string) (len=33) "\t0: _ColorWithComment3Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment3Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment3Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment3Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment3Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment3Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment3Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment3Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment3Name[42:52],", - (string) (len=35) "\t39: _ColorWithComment3Name[52:67],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=44) "func (x ColorWithComment3) String() string {", - (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", - (string) (len=51) "\t_ColorWithComment3Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment3Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment3Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): 2,", - (string) (len=52) "\t_ColorWithComment3Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment3Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment3Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment3Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment3Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment3Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): 38,", - (string) (len=52) "\t_ColorWithComment3Name[52:67]: 39,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): 39,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3", - (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", - (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is not a valid ColorWithComment3\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", - (string) (len=38) "\tv, err := ParseColorWithComment3(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=43) "func (x *ColorWithComment3) Type() string {", - (string) (len=27) "\treturn \"ColorWithComment3\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=18) "\t// Skipped value.", - (string) (len=15) "\t// Placeholder", - (string) (len=27) "\t_ ColorWithComment4 = iota", - (string) (len=47) "\t// Black is a ColorWithComment4 of type Black.", - (string) (len=6) "\tBlack", - (string) (len=47) "\t// White is a ColorWithComment4 of type White.", - (string) (len=6) "\tWhite", - (string) (len=43) "\t// Red is a ColorWithComment4 of type Red.", - (string) (len=4) "\tRed", - (string) (len=47) "\t// Green is a ColorWithComment4 of type Green.", - (string) (len=24) "\t// Green starts with 33", - (string) (len=36) "\tGreen ColorWithComment4 = iota + 29", - (string) (len=45) "\t// Blue is a ColorWithComment4 of type Blue.", - (string) (len=5) "\tBlue", - (string) (len=45) "\t// Grey is a ColorWithComment4 of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=49) "\t// Yellow is a ColorWithComment4 of type Yellow.", - (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", - (string) (len=7) "\tYellow", - (string) (len=56) "\t// BlueGreen is a ColorWithComment4 of type Blue-Green.", - (string) (len=22) "\t// blue-green comment", - (string) (len=10) "\tBlueGreen", - (string) (len=56) "\t// RedOrange is a ColorWithComment4 of type Red-Orange.", - (string) (len=20) "\t// has a , in it!?!", - (string) (len=10) "\tRedOrange", - (string) (len=1) ")", - (string) "", - (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", - (string) "", - (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", - (string) (len=33) "\t1: _ColorWithComment4Name[0:5],", - (string) (len=34) "\t2: _ColorWithComment4Name[5:10],", - (string) (len=35) "\t3: _ColorWithComment4Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment4Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment4Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment4Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment4Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment4Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment4Name[42:52],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=44) "func (x ColorWithComment4) String() string {", - (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", - (string) (len=51) "\t_ColorWithComment4Name[0:5]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): 1,", - (string) (len=51) "\t_ColorWithComment4Name[5:10]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): 2,", - (string) (len=51) "\t_ColorWithComment4Name[10:13]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): 3,", - (string) (len=52) "\t_ColorWithComment4Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment4Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment4Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment4Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment4Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment4Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): 38,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4", - (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", - (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is not a valid ColorWithComment4\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", - (string) (len=38) "\tv, err := ParseColorWithComment4(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=43) "func (x *ColorWithComment4) Type() string {", - (string) (len=27) "\treturn \"ColorWithComment4\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=37) "\t// Toyota is a Model of type Toyota.", - (string) (len=20) "\tToyota Model = iota", - (string) (len=18) "\t// Skipped value.", - (string) (len=2) "\t_", - (string) (len=35) "\t// Chevy is a Model of type Chevy.", - (string) (len=6) "\tChevy", - (string) (len=18) "\t// Skipped value.", - (string) (len=2) "\t_", - (string) (len=33) "\t// Ford is a Model of type Ford.", - (string) (len=5) "\tFord", - (string) (len=1) ")", - (string) "", - (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", - (string) "", - (string) (len=33) "var _ModelMap = map[Model]string{", - (string) (len=20) "\t0: _ModelName[0:6],", - (string) (len=21) "\t2: _ModelName[6:11],", - (string) (len=22) "\t4: _ModelName[11:15],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=32) "func (x Model) String() string {", - (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=35) "var _ModelValue = map[string]Model{", - (string) (len=39) "\t_ModelName[0:6]: 0,", - (string) (len=39) "\tstrings.ToLower(_ModelName[0:6]): 0,", - (string) (len=39) "\t_ModelName[6:11]: 2,", - (string) (len=39) "\tstrings.ToLower(_ModelName[6:11]): 2,", - (string) (len=39) "\t_ModelName[11:15]: 4,", - (string) (len=39) "\tstrings.ToLower(_ModelName[11:15]): 4,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseModel attempts to convert a string to a Model", - (string) (len=45) "func ParseModel(name string) (Model, error) {", - (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=61) "\treturn Model(0), fmt.Errorf(\"%s is not a valid Model\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=29) "\ttmp, err := ParseModel(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=39) "func (x *Model) Set(val string) error {", - (string) (len=26) "\tv, err := ParseModel(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=35) "func (x *Model) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=31) "func (x *Model) Type() string {", - (string) (len=15) "\treturn \"Model\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=51) "\t// TestHyphen is a Sanitizing of type Test-Hyphen.", - (string) (len=29) "\tTestHyphen Sanitizing = iota", - (string) (len=54) "\t// XHyphenStart is a Sanitizing of type -HyphenStart.", - (string) (len=13) "\tXHyphenStart", - (string) (len=63) "\t// X_underscoreFirst is a Sanitizing of type _underscoreFirst.", - (string) (len=18) "\tX_underscoreFirst", - (string) (len=55) "\t// X0numberFirst is a Sanitizing of type 0numberFirst.", - (string) (len=14) "\tX0numberFirst", - (string) (len=51) "\t// X123456789a is a Sanitizing of type 123456789a.", - (string) (len=12) "\tX123456789a", - (string) (len=52) "\t// X123123Asdf is a Sanitizing of type 123123-Asdf.", - (string) (len=12) "\tX123123Asdf", - (string) (len=56) "\t// EndingHyphen is a Sanitizing of type Ending-Hyphen-.", - (string) (len=13) "\tEndingHyphen", - (string) (len=1) ")", - (string) "", - (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", - (string) "", - (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", - (string) (len=26) "\t0: _SanitizingName[0:11],", - (string) (len=27) "\t1: _SanitizingName[11:23],", - (string) (len=27) "\t2: _SanitizingName[23:39],", - (string) (len=27) "\t3: _SanitizingName[39:51],", - (string) (len=27) "\t4: _SanitizingName[51:61],", - (string) (len=27) "\t5: _SanitizingName[61:72],", - (string) (len=27) "\t6: _SanitizingName[72:86],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=37) "func (x Sanitizing) String() string {", - (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", - (string) (len=44) "\t_SanitizingName[0:11]: 0,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[0:11]): 0,", - (string) (len=44) "\t_SanitizingName[11:23]: 1,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[11:23]): 1,", - (string) (len=44) "\t_SanitizingName[23:39]: 2,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[23:39]): 2,", - (string) (len=44) "\t_SanitizingName[39:51]: 3,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[39:51]): 3,", - (string) (len=44) "\t_SanitizingName[51:61]: 4,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[51:61]): 4,", - (string) (len=44) "\t_SanitizingName[61:72]: 5,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[61:72]): 5,", - (string) (len=44) "\t_SanitizingName[72:86]: 6,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[72:86]): 6,", - (string) (len=1) "}", - (string) "", - (string) (len=63) "// ParseSanitizing attempts to convert a string to a Sanitizing", - (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", - (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=71) "\treturn Sanitizing(0), fmt.Errorf(\"%s is not a valid Sanitizing\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=34) "\ttmp, err := ParseSanitizing(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=44) "func (x *Sanitizing) Set(val string) error {", - (string) (len=31) "\tv, err := ParseSanitizing(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=40) "func (x *Sanitizing) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=36) "func (x *Sanitizing) Type() string {", - (string) (len=20) "\treturn \"Sanitizing\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=32) "\t// Coke is a Soda of type Coke.", - (string) (len=17) "\tCoke Soda = iota", - (string) (len=34) "\t// Pepsi is a Soda of type Pepsi.", - (string) (len=6) "\tPepsi", - (string) (len=36) "\t// MtnDew is a Soda of type MtnDew.", - (string) (len=7) "\tMtnDew", - (string) (len=1) ")", - (string) "", - (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", - (string) "", - (string) (len=31) "var _SodaMap = map[Soda]string{", - (string) (len=19) "\t0: _SodaName[0:4],", - (string) (len=19) "\t1: _SodaName[4:9],", - (string) (len=20) "\t2: _SodaName[9:15],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=31) "func (x Soda) String() string {", - (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=33) "var _SodaValue = map[string]Soda{", - (string) (len=37) "\t_SodaName[0:4]: 0,", - (string) (len=37) "\tstrings.ToLower(_SodaName[0:4]): 0,", - (string) (len=37) "\t_SodaName[4:9]: 1,", - (string) (len=37) "\tstrings.ToLower(_SodaName[4:9]): 1,", - (string) (len=37) "\t_SodaName[9:15]: 2,", - (string) (len=37) "\tstrings.ToLower(_SodaName[9:15]): 2,", - (string) (len=1) "}", - (string) "", - (string) (len=51) "// ParseSoda attempts to convert a string to a Soda", - (string) (len=43) "func ParseSoda(name string) (Soda, error) {", - (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=59) "\treturn Soda(0), fmt.Errorf(\"%s is not a valid Soda\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=28) "\ttmp, err := ParseSoda(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=38) "func (x *Soda) Set(val string) error {", - (string) (len=25) "\tv, err := ParseSoda(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=34) "func (x *Soda) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=30) "func (x *Soda) Type() string {", - (string) (len=14) "\treturn \"Soda\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=56) "\t// StartWithNum is a StartNotZero of type StartWithNum.", - (string) (len=38) "\tStartWithNum StartNotZero = iota + 23", - (string) (len=46) "\t// NextNum is a StartNotZero of type NextNum.", - (string) (len=8) "\tNextNum", - (string) (len=1) ")", - (string) "", - (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", - (string) "", - (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", - (string) (len=29) "\t23: _StartNotZeroName[0:12],", - (string) (len=30) "\t24: _StartNotZeroName[12:19],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=39) "func (x StartNotZero) String() string {", - (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", - (string) (len=47) "\t_StartNotZeroName[0:12]: 23,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[0:12]): 23,", - (string) (len=47) "\t_StartNotZeroName[12:19]: 24,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[12:19]): 24,", - (string) (len=1) "}", - (string) "", - (string) (len=67) "// ParseStartNotZero attempts to convert a string to a StartNotZero", - (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", - (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=75) "\treturn StartNotZero(0), fmt.Errorf(\"%s is not a valid StartNotZero\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=46) "func (x *StartNotZero) Set(val string) error {", - (string) (len=33) "\tv, err := ParseStartNotZero(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=42) "func (x *StartNotZero) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=38) "func (x *StartNotZero) Type() string {", - (string) (len=22) "\treturn \"StartNotZero\"", - (string) (len=1) "}", - (string) "" -} diff --git a/generator/.snapshots/generator-TestNoPrefixExampleFileWithSnakeToCamel b/generator/.snapshots/generator-TestNoPrefixExampleFileWithSnakeToCamel deleted file mode 100644 index 1a4e7de8..00000000 --- a/generator/.snapshots/generator-TestNoPrefixExampleFileWithSnakeToCamel +++ /dev/null @@ -1,992 +0,0 @@ -([]string) (len=990) { - (string) (len=28) "// Code generated by go-enum", - (string) (len=15) "// DO NOT EDIT!", - (string) "", - (string) (len=17) "package generator", - (string) "", - (string) (len=8) "import (", - (string) (len=6) "\t\"fmt\"", - (string) (len=10) "\t\"strings\"", - (string) (len=1) ")", - (string) "", - (string) (len=7) "const (", - (string) (len=32) "\t// Cat is a Animal of type Cat.", - (string) (len=18) "\tCat Animal = iota", - (string) (len=32) "\t// Dog is a Animal of type Dog.", - (string) (len=4) "\tDog", - (string) (len=34) "\t// Fish is a Animal of type Fish.", - (string) (len=5) "\tFish", - (string) (len=1) ")", - (string) "", - (string) (len=32) "const _AnimalName = \"CatDogFish\"", - (string) "", - (string) (len=35) "var _AnimalMap = map[Animal]string{", - (string) (len=21) "\t0: _AnimalName[0:3],", - (string) (len=21) "\t1: _AnimalName[3:6],", - (string) (len=22) "\t2: _AnimalName[6:10],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=33) "func (x Animal) String() string {", - (string) (len=34) "\tif str, ok := _AnimalMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=36) "\treturn fmt.Sprintf(\"Animal(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=37) "var _AnimalValue = map[string]Animal{", - (string) (len=39) "\t_AnimalName[0:3]: 0,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[0:3]): 0,", - (string) (len=39) "\t_AnimalName[3:6]: 1,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[3:6]): 1,", - (string) (len=39) "\t_AnimalName[6:10]: 2,", - (string) (len=39) "\tstrings.ToLower(_AnimalName[6:10]): 2,", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// ParseAnimal attempts to convert a string to a Animal", - (string) (len=47) "func ParseAnimal(name string) (Animal, error) {", - (string) (len=37) "\tif x, ok := _AnimalValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=63) "\treturn Animal(0), fmt.Errorf(\"%s is not a valid Animal\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=47) "func (x Animal) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=51) "func (x *Animal) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=30) "\ttmp, err := ParseAnimal(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=40) "func (x *Animal) Set(val string) error {", - (string) (len=27) "\tv, err := ParseAnimal(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=36) "func (x *Animal) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=32) "func (x *Animal) Type() string {", - (string) (len=16) "\treturn \"Animal\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=44) "\t// TestLower is a Cases of type Test_lower.", - (string) (len=23) "\tTestLower Cases = iota", - (string) (len=48) "\t// TestCapital is a Cases of type Test_capital.", - (string) (len=12) "\tTestCapital", - (string) (len=67) "\t// AnotherLowerCaseStart is a Cases of type AnotherLowerCaseStart.", - (string) (len=22) "\tAnotherLowerCaseStart", - (string) (len=1) ")", - (string) "", - (string) (len=64) "const _CasesName = \"test_lowerTest_capitalanotherLowerCaseStart\"", - (string) "", - (string) (len=33) "var _CasesMap = map[Cases]string{", - (string) (len=21) "\t0: _CasesName[0:10],", - (string) (len=22) "\t1: _CasesName[10:22],", - (string) (len=22) "\t2: _CasesName[22:43],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=32) "func (x Cases) String() string {", - (string) (len=33) "\tif str, ok := _CasesMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=35) "\treturn fmt.Sprintf(\"Cases(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=35) "var _CasesValue = map[string]Cases{", - (string) (len=39) "\t_CasesName[0:10]: 0,", - (string) (len=39) "\tstrings.ToLower(_CasesName[0:10]): 0,", - (string) (len=39) "\t_CasesName[10:22]: 1,", - (string) (len=39) "\tstrings.ToLower(_CasesName[10:22]): 1,", - (string) (len=39) "\t_CasesName[22:43]: 2,", - (string) (len=39) "\tstrings.ToLower(_CasesName[22:43]): 2,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseCases attempts to convert a string to a Cases", - (string) (len=45) "func ParseCases(name string) (Cases, error) {", - (string) (len=36) "\tif x, ok := _CasesValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=61) "\treturn Cases(0), fmt.Errorf(\"%s is not a valid Cases\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=46) "func (x Cases) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=50) "func (x *Cases) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=29) "\ttmp, err := ParseCases(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=39) "func (x *Cases) Set(val string) error {", - (string) (len=26) "\tv, err := ParseCases(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=35) "func (x *Cases) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=31) "func (x *Cases) Type() string {", - (string) (len=15) "\treturn \"Cases\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=35) "\t// Black is a Color of type Black.", - (string) (len=19) "\tBlack Color = iota", - (string) (len=35) "\t// White is a Color of type White.", - (string) (len=6) "\tWhite", - (string) (len=31) "\t// Red is a Color of type Red.", - (string) (len=4) "\tRed", - (string) (len=35) "\t// Green is a Color of type Green.", - (string) (len=6) "\tGreen", - (string) (len=33) "\t// Blue is a Color of type Blue.", - (string) (len=23) "\tBlue Color = iota + 29", - (string) (len=33) "\t// Grey is a Color of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=37) "\t// Yellow is a Color of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=1) ")", - (string) "", - (string) (len=53) "const _ColorName = \"BlackWhiteRedGreenBluegreyyellow\"", - (string) "", - (string) (len=33) "var _ColorMap = map[Color]string{", - (string) (len=21) "\t0: _ColorName[0:5],", - (string) (len=22) "\t1: _ColorName[5:10],", - (string) (len=23) "\t2: _ColorName[10:13],", - (string) (len=23) "\t3: _ColorName[13:18],", - (string) (len=23) "\t33: _ColorName[18:22],", - (string) (len=23) "\t34: _ColorName[22:26],", - (string) (len=23) "\t35: _ColorName[26:32],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=32) "func (x Color) String() string {", - (string) (len=33) "\tif str, ok := _ColorMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=35) "\treturn fmt.Sprintf(\"Color(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=35) "var _ColorValue = map[string]Color{", - (string) (len=39) "\t_ColorName[0:5]: 0,", - (string) (len=39) "\tstrings.ToLower(_ColorName[0:5]): 0,", - (string) (len=39) "\t_ColorName[5:10]: 1,", - (string) (len=39) "\tstrings.ToLower(_ColorName[5:10]): 1,", - (string) (len=39) "\t_ColorName[10:13]: 2,", - (string) (len=39) "\tstrings.ToLower(_ColorName[10:13]): 2,", - (string) (len=39) "\t_ColorName[13:18]: 3,", - (string) (len=39) "\tstrings.ToLower(_ColorName[13:18]): 3,", - (string) (len=40) "\t_ColorName[18:22]: 33,", - (string) (len=40) "\tstrings.ToLower(_ColorName[18:22]): 33,", - (string) (len=40) "\t_ColorName[22:26]: 34,", - (string) (len=40) "\tstrings.ToLower(_ColorName[22:26]): 34,", - (string) (len=40) "\t_ColorName[26:32]: 35,", - (string) (len=40) "\tstrings.ToLower(_ColorName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseColor attempts to convert a string to a Color", - (string) (len=45) "func ParseColor(name string) (Color, error) {", - (string) (len=36) "\tif x, ok := _ColorValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=61) "\treturn Color(0), fmt.Errorf(\"%s is not a valid Color\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=46) "func (x Color) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=50) "func (x *Color) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=29) "\ttmp, err := ParseColor(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=39) "func (x *Color) Set(val string) error {", - (string) (len=26) "\tv, err := ParseColor(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=35) "func (x *Color) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=31) "func (x *Color) Type() string {", - (string) (len=15) "\treturn \"Color\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=46) "\t// Black is a ColorWithComment of type Black.", - (string) (len=30) "\tBlack ColorWithComment = iota", - (string) (len=46) "\t// White is a ColorWithComment of type White.", - (string) (len=6) "\tWhite", - (string) (len=42) "\t// Red is a ColorWithComment of type Red.", - (string) (len=4) "\tRed", - (string) (len=46) "\t// Green is a ColorWithComment of type Green.", - (string) (len=6) "\tGreen", - (string) (len=44) "\t// Blue is a ColorWithComment of type Blue.", - (string) (len=23) "\t// Blue starts with 33", - (string) (len=34) "\tBlue ColorWithComment = iota + 29", - (string) (len=44) "\t// Grey is a ColorWithComment of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=48) "\t// Yellow is a ColorWithComment of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=1) ")", - (string) "", - (string) (len=64) "const _ColorWithCommentName = \"BlackWhiteRedGreenBluegreyyellow\"", - (string) "", - (string) (len=55) "var _ColorWithCommentMap = map[ColorWithComment]string{", - (string) (len=32) "\t0: _ColorWithCommentName[0:5],", - (string) (len=33) "\t1: _ColorWithCommentName[5:10],", - (string) (len=34) "\t2: _ColorWithCommentName[10:13],", - (string) (len=34) "\t3: _ColorWithCommentName[13:18],", - (string) (len=34) "\t33: _ColorWithCommentName[18:22],", - (string) (len=34) "\t34: _ColorWithCommentName[22:26],", - (string) (len=34) "\t35: _ColorWithCommentName[26:32],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=43) "func (x ColorWithComment) String() string {", - (string) (len=44) "\tif str, ok := _ColorWithCommentMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=46) "\treturn fmt.Sprintf(\"ColorWithComment(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=57) "var _ColorWithCommentValue = map[string]ColorWithComment{", - (string) (len=50) "\t_ColorWithCommentName[0:5]: 0,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[0:5]): 0,", - (string) (len=50) "\t_ColorWithCommentName[5:10]: 1,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[5:10]): 1,", - (string) (len=50) "\t_ColorWithCommentName[10:13]: 2,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[10:13]): 2,", - (string) (len=50) "\t_ColorWithCommentName[13:18]: 3,", - (string) (len=50) "\tstrings.ToLower(_ColorWithCommentName[13:18]): 3,", - (string) (len=51) "\t_ColorWithCommentName[18:22]: 33,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[18:22]): 33,", - (string) (len=51) "\t_ColorWithCommentName[22:26]: 34,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[22:26]): 34,", - (string) (len=51) "\t_ColorWithCommentName[26:32]: 35,", - (string) (len=51) "\tstrings.ToLower(_ColorWithCommentName[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=75) "// ParseColorWithComment attempts to convert a string to a ColorWithComment", - (string) (len=67) "func ParseColorWithComment(name string) (ColorWithComment, error) {", - (string) (len=47) "\tif x, ok := _ColorWithCommentValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=83) "\treturn ColorWithComment(0), fmt.Errorf(\"%s is not a valid ColorWithComment\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=57) "func (x ColorWithComment) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=61) "func (x *ColorWithComment) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=40) "\ttmp, err := ParseColorWithComment(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=50) "func (x *ColorWithComment) Set(val string) error {", - (string) (len=37) "\tv, err := ParseColorWithComment(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=46) "func (x *ColorWithComment) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=42) "func (x *ColorWithComment) Type() string {", - (string) (len=26) "\treturn \"ColorWithComment\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=47) "\t// Black is a ColorWithComment2 of type Black.", - (string) (len=31) "\tBlack ColorWithComment2 = iota", - (string) (len=47) "\t// White is a ColorWithComment2 of type White.", - (string) (len=6) "\tWhite", - (string) (len=43) "\t// Red is a ColorWithComment2 of type Red.", - (string) (len=4) "\tRed", - (string) (len=47) "\t// Green is a ColorWithComment2 of type Green.", - (string) (len=6) "\tGreen", - (string) (len=45) "\t// Blue is a ColorWithComment2 of type Blue.", - (string) (len=23) "\t// Blue starts with 33", - (string) (len=35) "\tBlue ColorWithComment2 = iota + 29", - (string) (len=45) "\t// Grey is a ColorWithComment2 of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=49) "\t// Yellow is a ColorWithComment2 of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=1) ")", - (string) "", - (string) (len=65) "const _ColorWithComment2Name = \"BlackWhiteRedGreenBluegreyyellow\"", - (string) "", - (string) (len=57) "var _ColorWithComment2Map = map[ColorWithComment2]string{", - (string) (len=33) "\t0: _ColorWithComment2Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment2Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment2Name[10:13],", - (string) (len=35) "\t3: _ColorWithComment2Name[13:18],", - (string) (len=35) "\t33: _ColorWithComment2Name[18:22],", - (string) (len=35) "\t34: _ColorWithComment2Name[22:26],", - (string) (len=35) "\t35: _ColorWithComment2Name[26:32],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=44) "func (x ColorWithComment2) String() string {", - (string) (len=45) "\tif str, ok := _ColorWithComment2Map[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment2(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=59) "var _ColorWithComment2Value = map[string]ColorWithComment2{", - (string) (len=51) "\t_ColorWithComment2Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment2Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment2Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[10:13]): 2,", - (string) (len=51) "\t_ColorWithComment2Name[13:18]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment2Name[13:18]): 3,", - (string) (len=52) "\t_ColorWithComment2Name[18:22]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[18:22]): 33,", - (string) (len=52) "\t_ColorWithComment2Name[22:26]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[22:26]): 34,", - (string) (len=52) "\t_ColorWithComment2Name[26:32]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment2Name[26:32]): 35,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment2 attempts to convert a string to a ColorWithComment2", - (string) (len=69) "func ParseColorWithComment2(name string) (ColorWithComment2, error) {", - (string) (len=48) "\tif x, ok := _ColorWithComment2Value[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment2(0), fmt.Errorf(\"%s is not a valid ColorWithComment2\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=58) "func (x ColorWithComment2) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=62) "func (x *ColorWithComment2) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=41) "\ttmp, err := ParseColorWithComment2(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=51) "func (x *ColorWithComment2) Set(val string) error {", - (string) (len=38) "\tv, err := ParseColorWithComment2(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=47) "func (x *ColorWithComment2) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=43) "func (x *ColorWithComment2) Type() string {", - (string) (len=27) "\treturn \"ColorWithComment2\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=47) "\t// Black is a ColorWithComment3 of type Black.", - (string) (len=31) "\tBlack ColorWithComment3 = iota", - (string) (len=47) "\t// White is a ColorWithComment3 of type White.", - (string) (len=6) "\tWhite", - (string) (len=43) "\t// Red is a ColorWithComment3 of type Red.", - (string) (len=4) "\tRed", - (string) (len=47) "\t// Green is a ColorWithComment3 of type Green.", - (string) (len=24) "\t// Green starts with 33", - (string) (len=36) "\tGreen ColorWithComment3 = iota + 30", - (string) (len=45) "\t// Blue is a ColorWithComment3 of type Blue.", - (string) (len=5) "\tBlue", - (string) (len=45) "\t// Grey is a ColorWithComment3 of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=49) "\t// Yellow is a ColorWithComment3 of type Yellow.", - (string) (len=7) "\tYellow", - (string) (len=56) "\t// BlueGreen is a ColorWithComment3 of type Blue-Green.", - (string) (len=22) "\t// blue-green comment", - (string) (len=10) "\tBlueGreen", - (string) (len=56) "\t// RedOrange is a ColorWithComment3 of type Red-Orange.", - (string) (len=10) "\tRedOrange", - (string) (len=65) "\t// RedOrangeBlue is a ColorWithComment3 of type Red-Orange-Blue.", - (string) (len=14) "\tRedOrangeBlue", - (string) (len=1) ")", - (string) "", - (string) (len=100) "const _ColorWithComment3Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orangered-orange-blue\"", - (string) "", - (string) (len=57) "var _ColorWithComment3Map = map[ColorWithComment3]string{", - (string) (len=33) "\t0: _ColorWithComment3Name[0:5],", - (string) (len=34) "\t1: _ColorWithComment3Name[5:10],", - (string) (len=35) "\t2: _ColorWithComment3Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment3Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment3Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment3Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment3Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment3Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment3Name[42:52],", - (string) (len=35) "\t39: _ColorWithComment3Name[52:67],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=44) "func (x ColorWithComment3) String() string {", - (string) (len=45) "\tif str, ok := _ColorWithComment3Map[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment3(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=59) "var _ColorWithComment3Value = map[string]ColorWithComment3{", - (string) (len=51) "\t_ColorWithComment3Name[0:5]: 0,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[0:5]): 0,", - (string) (len=51) "\t_ColorWithComment3Name[5:10]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[5:10]): 1,", - (string) (len=51) "\t_ColorWithComment3Name[10:13]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment3Name[10:13]): 2,", - (string) (len=52) "\t_ColorWithComment3Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment3Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment3Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment3Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment3Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment3Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[42:52]): 38,", - (string) (len=52) "\t_ColorWithComment3Name[52:67]: 39,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment3Name[52:67]): 39,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment3 attempts to convert a string to a ColorWithComment3", - (string) (len=69) "func ParseColorWithComment3(name string) (ColorWithComment3, error) {", - (string) (len=48) "\tif x, ok := _ColorWithComment3Value[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment3(0), fmt.Errorf(\"%s is not a valid ColorWithComment3\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=58) "func (x ColorWithComment3) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=62) "func (x *ColorWithComment3) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=41) "\ttmp, err := ParseColorWithComment3(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=51) "func (x *ColorWithComment3) Set(val string) error {", - (string) (len=38) "\tv, err := ParseColorWithComment3(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=47) "func (x *ColorWithComment3) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=43) "func (x *ColorWithComment3) Type() string {", - (string) (len=27) "\treturn \"ColorWithComment3\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=18) "\t// Skipped value.", - (string) (len=15) "\t// Placeholder", - (string) (len=27) "\t_ ColorWithComment4 = iota", - (string) (len=47) "\t// Black is a ColorWithComment4 of type Black.", - (string) (len=6) "\tBlack", - (string) (len=47) "\t// White is a ColorWithComment4 of type White.", - (string) (len=6) "\tWhite", - (string) (len=43) "\t// Red is a ColorWithComment4 of type Red.", - (string) (len=4) "\tRed", - (string) (len=47) "\t// Green is a ColorWithComment4 of type Green.", - (string) (len=24) "\t// Green starts with 33", - (string) (len=36) "\tGreen ColorWithComment4 = iota + 29", - (string) (len=45) "\t// Blue is a ColorWithComment4 of type Blue.", - (string) (len=5) "\tBlue", - (string) (len=45) "\t// Grey is a ColorWithComment4 of type Grey.", - (string) (len=5) "\tGrey", - (string) (len=49) "\t// Yellow is a ColorWithComment4 of type Yellow.", - (string) (len=110) "\t// Where did all the (somewhat) bad fish go? (something else that goes in parentheses at the end of the line)", - (string) (len=7) "\tYellow", - (string) (len=56) "\t// BlueGreen is a ColorWithComment4 of type Blue-Green.", - (string) (len=22) "\t// blue-green comment", - (string) (len=10) "\tBlueGreen", - (string) (len=56) "\t// RedOrange is a ColorWithComment4 of type Red-Orange.", - (string) (len=20) "\t// has a , in it!?!", - (string) (len=10) "\tRedOrange", - (string) (len=1) ")", - (string) "", - (string) (len=85) "const _ColorWithComment4Name = \"BlackWhiteRedGreenBluegreyyellowblue-greenred-orange\"", - (string) "", - (string) (len=57) "var _ColorWithComment4Map = map[ColorWithComment4]string{", - (string) (len=33) "\t1: _ColorWithComment4Name[0:5],", - (string) (len=34) "\t2: _ColorWithComment4Name[5:10],", - (string) (len=35) "\t3: _ColorWithComment4Name[10:13],", - (string) (len=35) "\t33: _ColorWithComment4Name[13:18],", - (string) (len=35) "\t34: _ColorWithComment4Name[18:22],", - (string) (len=35) "\t35: _ColorWithComment4Name[22:26],", - (string) (len=35) "\t36: _ColorWithComment4Name[26:32],", - (string) (len=35) "\t37: _ColorWithComment4Name[32:42],", - (string) (len=35) "\t38: _ColorWithComment4Name[42:52],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=44) "func (x ColorWithComment4) String() string {", - (string) (len=45) "\tif str, ok := _ColorWithComment4Map[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=47) "\treturn fmt.Sprintf(\"ColorWithComment4(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=59) "var _ColorWithComment4Value = map[string]ColorWithComment4{", - (string) (len=51) "\t_ColorWithComment4Name[0:5]: 1,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[0:5]): 1,", - (string) (len=51) "\t_ColorWithComment4Name[5:10]: 2,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[5:10]): 2,", - (string) (len=51) "\t_ColorWithComment4Name[10:13]: 3,", - (string) (len=51) "\tstrings.ToLower(_ColorWithComment4Name[10:13]): 3,", - (string) (len=52) "\t_ColorWithComment4Name[13:18]: 33,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[13:18]): 33,", - (string) (len=52) "\t_ColorWithComment4Name[18:22]: 34,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[18:22]): 34,", - (string) (len=52) "\t_ColorWithComment4Name[22:26]: 35,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[22:26]): 35,", - (string) (len=52) "\t_ColorWithComment4Name[26:32]: 36,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[26:32]): 36,", - (string) (len=52) "\t_ColorWithComment4Name[32:42]: 37,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[32:42]): 37,", - (string) (len=52) "\t_ColorWithComment4Name[42:52]: 38,", - (string) (len=52) "\tstrings.ToLower(_ColorWithComment4Name[42:52]): 38,", - (string) (len=1) "}", - (string) "", - (string) (len=77) "// ParseColorWithComment4 attempts to convert a string to a ColorWithComment4", - (string) (len=69) "func ParseColorWithComment4(name string) (ColorWithComment4, error) {", - (string) (len=48) "\tif x, ok := _ColorWithComment4Value[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=85) "\treturn ColorWithComment4(0), fmt.Errorf(\"%s is not a valid ColorWithComment4\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=58) "func (x ColorWithComment4) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=62) "func (x *ColorWithComment4) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=41) "\ttmp, err := ParseColorWithComment4(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=51) "func (x *ColorWithComment4) Set(val string) error {", - (string) (len=38) "\tv, err := ParseColorWithComment4(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=47) "func (x *ColorWithComment4) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=43) "func (x *ColorWithComment4) Type() string {", - (string) (len=27) "\treturn \"ColorWithComment4\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=37) "\t// Toyota is a Model of type Toyota.", - (string) (len=20) "\tToyota Model = iota", - (string) (len=18) "\t// Skipped value.", - (string) (len=2) "\t_", - (string) (len=35) "\t// Chevy is a Model of type Chevy.", - (string) (len=6) "\tChevy", - (string) (len=18) "\t// Skipped value.", - (string) (len=2) "\t_", - (string) (len=33) "\t// Ford is a Model of type Ford.", - (string) (len=5) "\tFord", - (string) (len=1) ")", - (string) "", - (string) (len=36) "const _ModelName = \"ToyotaChevyFord\"", - (string) "", - (string) (len=33) "var _ModelMap = map[Model]string{", - (string) (len=20) "\t0: _ModelName[0:6],", - (string) (len=21) "\t2: _ModelName[6:11],", - (string) (len=22) "\t4: _ModelName[11:15],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=32) "func (x Model) String() string {", - (string) (len=33) "\tif str, ok := _ModelMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=35) "\treturn fmt.Sprintf(\"Model(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=35) "var _ModelValue = map[string]Model{", - (string) (len=39) "\t_ModelName[0:6]: 0,", - (string) (len=39) "\tstrings.ToLower(_ModelName[0:6]): 0,", - (string) (len=39) "\t_ModelName[6:11]: 2,", - (string) (len=39) "\tstrings.ToLower(_ModelName[6:11]): 2,", - (string) (len=39) "\t_ModelName[11:15]: 4,", - (string) (len=39) "\tstrings.ToLower(_ModelName[11:15]): 4,", - (string) (len=1) "}", - (string) "", - (string) (len=53) "// ParseModel attempts to convert a string to a Model", - (string) (len=45) "func ParseModel(name string) (Model, error) {", - (string) (len=36) "\tif x, ok := _ModelValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=61) "\treturn Model(0), fmt.Errorf(\"%s is not a valid Model\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=46) "func (x Model) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=50) "func (x *Model) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=29) "\ttmp, err := ParseModel(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=39) "func (x *Model) Set(val string) error {", - (string) (len=26) "\tv, err := ParseModel(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=35) "func (x *Model) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=31) "func (x *Model) Type() string {", - (string) (len=15) "\treturn \"Model\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=51) "\t// TestHyphen is a Sanitizing of type Test-Hyphen.", - (string) (len=29) "\tTestHyphen Sanitizing = iota", - (string) (len=54) "\t// XHyphenStart is a Sanitizing of type -HyphenStart.", - (string) (len=13) "\tXHyphenStart", - (string) (len=62) "\t// XUnderscoreFirst is a Sanitizing of type _underscoreFirst.", - (string) (len=17) "\tXUnderscoreFirst", - (string) (len=55) "\t// X0numberFirst is a Sanitizing of type 0numberFirst.", - (string) (len=14) "\tX0numberFirst", - (string) (len=51) "\t// X123456789a is a Sanitizing of type 123456789a.", - (string) (len=12) "\tX123456789a", - (string) (len=52) "\t// X123123Asdf is a Sanitizing of type 123123-Asdf.", - (string) (len=12) "\tX123123Asdf", - (string) (len=56) "\t// EndingHyphen is a Sanitizing of type Ending-Hyphen-.", - (string) (len=13) "\tEndingHyphen", - (string) (len=1) ")", - (string) "", - (string) (len=112) "const _SanitizingName = \"test-Hyphen-hyphenStart_underscoreFirst0numberFirst123456789a123123-asdfending-hyphen-\"", - (string) "", - (string) (len=43) "var _SanitizingMap = map[Sanitizing]string{", - (string) (len=26) "\t0: _SanitizingName[0:11],", - (string) (len=27) "\t1: _SanitizingName[11:23],", - (string) (len=27) "\t2: _SanitizingName[23:39],", - (string) (len=27) "\t3: _SanitizingName[39:51],", - (string) (len=27) "\t4: _SanitizingName[51:61],", - (string) (len=27) "\t5: _SanitizingName[61:72],", - (string) (len=27) "\t6: _SanitizingName[72:86],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=37) "func (x Sanitizing) String() string {", - (string) (len=38) "\tif str, ok := _SanitizingMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=40) "\treturn fmt.Sprintf(\"Sanitizing(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=45) "var _SanitizingValue = map[string]Sanitizing{", - (string) (len=44) "\t_SanitizingName[0:11]: 0,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[0:11]): 0,", - (string) (len=44) "\t_SanitizingName[11:23]: 1,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[11:23]): 1,", - (string) (len=44) "\t_SanitizingName[23:39]: 2,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[23:39]): 2,", - (string) (len=44) "\t_SanitizingName[39:51]: 3,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[39:51]): 3,", - (string) (len=44) "\t_SanitizingName[51:61]: 4,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[51:61]): 4,", - (string) (len=44) "\t_SanitizingName[61:72]: 5,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[61:72]): 5,", - (string) (len=44) "\t_SanitizingName[72:86]: 6,", - (string) (len=44) "\tstrings.ToLower(_SanitizingName[72:86]): 6,", - (string) (len=1) "}", - (string) "", - (string) (len=63) "// ParseSanitizing attempts to convert a string to a Sanitizing", - (string) (len=55) "func ParseSanitizing(name string) (Sanitizing, error) {", - (string) (len=41) "\tif x, ok := _SanitizingValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=71) "\treturn Sanitizing(0), fmt.Errorf(\"%s is not a valid Sanitizing\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=51) "func (x Sanitizing) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=55) "func (x *Sanitizing) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=34) "\ttmp, err := ParseSanitizing(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=44) "func (x *Sanitizing) Set(val string) error {", - (string) (len=31) "\tv, err := ParseSanitizing(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=40) "func (x *Sanitizing) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=36) "func (x *Sanitizing) Type() string {", - (string) (len=20) "\treturn \"Sanitizing\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=32) "\t// Coke is a Soda of type Coke.", - (string) (len=17) "\tCoke Soda = iota", - (string) (len=34) "\t// Pepsi is a Soda of type Pepsi.", - (string) (len=6) "\tPepsi", - (string) (len=36) "\t// MtnDew is a Soda of type MtnDew.", - (string) (len=7) "\tMtnDew", - (string) (len=1) ")", - (string) "", - (string) (len=35) "const _SodaName = \"CokePepsiMtnDew\"", - (string) "", - (string) (len=31) "var _SodaMap = map[Soda]string{", - (string) (len=19) "\t0: _SodaName[0:4],", - (string) (len=19) "\t1: _SodaName[4:9],", - (string) (len=20) "\t2: _SodaName[9:15],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=31) "func (x Soda) String() string {", - (string) (len=32) "\tif str, ok := _SodaMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=34) "\treturn fmt.Sprintf(\"Soda(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=33) "var _SodaValue = map[string]Soda{", - (string) (len=37) "\t_SodaName[0:4]: 0,", - (string) (len=37) "\tstrings.ToLower(_SodaName[0:4]): 0,", - (string) (len=37) "\t_SodaName[4:9]: 1,", - (string) (len=37) "\tstrings.ToLower(_SodaName[4:9]): 1,", - (string) (len=37) "\t_SodaName[9:15]: 2,", - (string) (len=37) "\tstrings.ToLower(_SodaName[9:15]): 2,", - (string) (len=1) "}", - (string) "", - (string) (len=51) "// ParseSoda attempts to convert a string to a Soda", - (string) (len=43) "func ParseSoda(name string) (Soda, error) {", - (string) (len=35) "\tif x, ok := _SodaValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=59) "\treturn Soda(0), fmt.Errorf(\"%s is not a valid Soda\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=45) "func (x Soda) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=49) "func (x *Soda) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=28) "\ttmp, err := ParseSoda(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=38) "func (x *Soda) Set(val string) error {", - (string) (len=25) "\tv, err := ParseSoda(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=34) "func (x *Soda) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=30) "func (x *Soda) Type() string {", - (string) (len=14) "\treturn \"Soda\"", - (string) (len=1) "}", - (string) "", - (string) (len=7) "const (", - (string) (len=56) "\t// StartWithNum is a StartNotZero of type StartWithNum.", - (string) (len=38) "\tStartWithNum StartNotZero = iota + 23", - (string) (len=46) "\t// NextNum is a StartNotZero of type NextNum.", - (string) (len=8) "\tNextNum", - (string) (len=1) ")", - (string) "", - (string) (len=47) "const _StartNotZeroName = \"startWithNumnextNum\"", - (string) "", - (string) (len=47) "var _StartNotZeroMap = map[StartNotZero]string{", - (string) (len=29) "\t23: _StartNotZeroName[0:12],", - (string) (len=30) "\t24: _StartNotZeroName[12:19],", - (string) (len=1) "}", - (string) "", - (string) (len=44) "// String implements the Stringer interface.", - (string) (len=39) "func (x StartNotZero) String() string {", - (string) (len=40) "\tif str, ok := _StartNotZeroMap[x]; ok {", - (string) (len=12) "\t\treturn str", - (string) (len=2) "\t}", - (string) (len=42) "\treturn fmt.Sprintf(\"StartNotZero(%d)\", x)", - (string) (len=1) "}", - (string) "", - (string) (len=49) "var _StartNotZeroValue = map[string]StartNotZero{", - (string) (len=47) "\t_StartNotZeroName[0:12]: 23,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[0:12]): 23,", - (string) (len=47) "\t_StartNotZeroName[12:19]: 24,", - (string) (len=47) "\tstrings.ToLower(_StartNotZeroName[12:19]): 24,", - (string) (len=1) "}", - (string) "", - (string) (len=67) "// ParseStartNotZero attempts to convert a string to a StartNotZero", - (string) (len=59) "func ParseStartNotZero(name string) (StartNotZero, error) {", - (string) (len=43) "\tif x, ok := _StartNotZeroValue[name]; ok {", - (string) (len=15) "\t\treturn x, nil", - (string) (len=2) "\t}", - (string) (len=75) "\treturn StartNotZero(0), fmt.Errorf(\"%s is not a valid StartNotZero\", name)", - (string) (len=1) "}", - (string) "", - (string) (len=52) "// MarshalText implements the text marshaller method", - (string) (len=53) "func (x StartNotZero) MarshalText() ([]byte, error) {", - (string) (len=31) "\treturn []byte(x.String()), nil", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// UnmarshalText implements the text unmarshaller method", - (string) (len=57) "func (x *StartNotZero) UnmarshalText(text []byte) error {", - (string) (len=21) "\tname := string(text)", - (string) (len=36) "\ttmp, err := ParseStartNotZero(name)", - (string) (len=16) "\tif err != nil {", - (string) (len=12) "\t\treturn err", - (string) (len=2) "\t}", - (string) (len=9) "\t*x = tmp", - (string) (len=11) "\treturn nil", - (string) (len=1) "}", - (string) "", - (string) (len=55) "// Set implements the Golang flag.Value interface func.", - (string) (len=46) "func (x *StartNotZero) Set(val string) error {", - (string) (len=33) "\tv, err := ParseStartNotZero(val)", - (string) (len=7) "\t*x = v", - (string) (len=11) "\treturn err", - (string) (len=1) "}", - (string) "", - (string) (len=56) "// Get implements the Golang flag.Getter interface func.", - (string) (len=42) "func (x *StartNotZero) Get() interface{} {", - (string) (len=10) "\treturn *x", - (string) (len=1) "}", - (string) "", - (string) (len=62) "// Type implements the github.com/spf13/pFlag Value interface.", - (string) (len=38) "func (x *StartNotZero) Type() string {", - (string) (len=22) "\treturn \"StartNotZero\"", - (string) (len=1) "}", - (string) "" -} diff --git a/generator/assets/assets.go b/generator/assets/assets.go deleted file mode 100644 index 03dcd055..00000000 --- a/generator/assets/assets.go +++ /dev/null @@ -1,274 +0,0 @@ -// Code generated by go-bindata. DO NOT EDIT. -// sources: -// enum.tmpl (8.266kB) - -package assets - -import ( - "bytes" - "compress/gzip" - "crypto/sha256" - "fmt" - "io" - "io/ioutil" - "os" - "path/filepath" - "strings" - "time" -) - -func bindataRead(data []byte, name string) ([]byte, error) { - gz, err := gzip.NewReader(bytes.NewBuffer(data)) - if err != nil { - return nil, fmt.Errorf("read %q: %w", name, err) - } - - var buf bytes.Buffer - _, err = io.Copy(&buf, gz) - clErr := gz.Close() - - if err != nil { - return nil, fmt.Errorf("read %q: %w", name, err) - } - if clErr != nil { - return nil, err - } - - return buf.Bytes(), nil -} - -type asset struct { - bytes []byte - info os.FileInfo - digest [sha256.Size]byte -} - -type bindataFileInfo struct { - name string - size int64 - mode os.FileMode - modTime time.Time -} - -func (fi bindataFileInfo) Name() string { - return fi.name -} -func (fi bindataFileInfo) Size() int64 { - return fi.size -} -func (fi bindataFileInfo) Mode() os.FileMode { - return fi.mode -} -func (fi bindataFileInfo) ModTime() time.Time { - return fi.modTime -} -func (fi bindataFileInfo) IsDir() bool { - return false -} -func (fi bindataFileInfo) Sys() interface{} { - return nil -} - -var _enumTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xe4\x19\x4d\x8f\xdb\xb8\xf5\x6c\xfd\x8a\x17\x21\xd9\x95\x5c\x47\x4e\xd1\xa2\x87\x2c\xe6\x10\x64\xd3\x60\x17\xcd\x24\xc0\xa4\x7b\x09\x82\x80\x96\x9e\xc6\xdc\x91\x48\x2d\x49\x79\xe4\xaa\xfa\xef\xc5\x23\x29\x59\xd6\xc8\x33\xd3\x74\x66\x83\x62\x2f\x86\x45\x3e\xbe\xef\x4f\xb2\x6d\x9f\x43\x86\x39\x17\x08\xe1\x16\x59\x86\x2a\xec\xba\x60\xbd\x86\xd7\x32\x43\xb8\x44\x81\x8a\x19\xcc\x60\xb3\x87\x4b\xf9\x1c\x45\x5d\xd2\xe6\x8f\xef\xe1\xfc\xfd\x47\x78\xf3\xe3\x4f\x1f\x9f\x04\x41\xc5\xd2\x2b\x76\x89\xd0\xb6\x89\xff\xdb\x75\x41\xc0\xcb\x4a\x2a\x03\x51\x00\x00\x10\xe6\xa5\x09\x83\x38\x68\x5b\x14\x19\x3c\xa7\xfd\x31\x65\xc2\x4b\x74\x53\x29\x34\x1d\xa1\xbd\xa7\xb4\x78\xce\x4a\x84\x97\x67\x90\xd0\x47\x62\xbf\xe8\xb0\xdd\xdf\x31\xa5\x69\x2f\xe3\xa9\x81\xb0\x60\xda\xc8\x3c\xd7\x68\x42\x78\xe1\x81\x40\x31\x71\x89\xf0\x54\xfd\x24\x32\x6c\x56\x74\xa4\xa8\x47\xf8\x7e\xa1\x4f\x0d\x5d\x17\x2c\x2c\x46\xc2\xf1\xde\xe2\x20\x98\xaa\xa8\xd3\xab\x63\xc4\x8e\xe6\xbf\x21\xe7\x4a\x1b\xe8\xba\xb6\x85\xa7\x72\x38\xa0\xeb\x8d\x27\xe1\x30\xf7\x84\x3d\x01\xe0\x39\xe0\x6f\x3d\x84\x95\x25\xfc\x12\x76\xdd\x7a\x0d\x17\x57\xbc\xaa\x30\x03\xb7\xd5\xb6\x58\x68\xb4\x1b\x6d\xeb\xc1\x3f\x28\xcc\x79\x83\x19\x1d\xeb\x3a\xe0\x1a\x18\x6d\xf6\x3a\xea\x3a\x90\x39\x98\x7d\x85\x87\x23\x6e\x3d\xb1\x2a\xef\x45\xe4\x79\x4f\xff\xb5\x2c\x4b\x14\x86\x36\xc6\x74\x46\xcb\x04\xef\x8e\x92\x05\x4f\x71\x72\x90\xcb\x0b\xfb\xc2\xea\x65\xcc\xd9\x19\x70\x69\x98\x03\x14\x08\x2f\x06\x9d\x75\x1d\xfc\x09\x46\x3a\xa4\x83\x96\xa2\xd3\x80\x87\x1f\x9b\x65\x0c\x79\x93\xc4\x49\x6c\x4f\xbf\x58\xfb\x10\x02\x6b\xc1\x63\xa3\xba\x3f\xde\xad\x9c\xc4\x31\xf9\x27\x18\x2c\xab\x82\x19\x84\x50\x1b\xc5\xc5\x25\xaa\x10\x12\xb2\x26\xc5\xc0\x07\xa6\x34\xb6\xed\xc1\x33\xbb\x0e\x98\xa1\x23\x46\x83\x91\x90\x4a\xb1\x43\x65\x80\x81\x3b\x4c\x6b\x64\xb3\xf1\x81\x20\xaf\x45\x3a\x87\x29\x12\xe4\x1e\xee\x60\x0c\xd1\xf1\xe6\x0a\x50\x29\xa9\x62\x68\x83\x05\xcf\xa1\x59\x81\xbc\x22\xf9\xbe\x1c\x83\x59\x1f\xfc\x44\x88\x3e\xff\x40\x10\x6d\xb0\x58\x28\x34\xb5\x12\x74\x44\xf0\x22\x58\x74\x6d\xcb\x73\x48\x84\x4c\x99\x46\xf0\xbe\xf0\x9a\xfe\x73\xa1\x51\x68\x6e\xf8\x0e\xa1\x22\xfe\x56\x90\x11\xff\x1a\x2b\x46\x19\x01\x0a\x29\xaf\xea\x8a\x84\xaa\x14\xee\x50\x18\xa8\x85\xc0\x14\xb5\x66\x6a\x0f\xa9\xd4\x86\x3c\xb2\x90\xd7\xa8\x52\xa6\x49\xfe\x41\x11\x3c\x87\x6b\x84\x4c\x8a\xef\x0d\x08\xc4\x0c\x8c\x4c\xee\x21\x89\x3b\xad\x93\x8f\xf2\x1f\x84\xd5\xaa\x28\xbe\x4d\xb4\xde\x98\x0b\x2f\x25\x2b\x51\xdb\xcc\xd0\xc3\x4e\x74\xfe\x22\x5e\x41\x5e\x9a\xe4\x0d\x69\x37\x8f\xc2\x67\x9a\xe2\x4c\x48\xb2\xe1\x8e\x15\x3c\x83\xa9\x1d\x8c\xda\xc3\xa7\x67\xfa\x73\xb8\x02\xc2\xbe\x82\x9e\xc7\x9f\x25\x17\xd1\x44\x0a\xfa\xd5\x2b\x08\x57\x10\xc6\xb1\x0f\x2f\xf2\xf2\x07\xe4\xc8\xf3\x11\x8f\x83\xd7\xa6\x5a\xd2\x79\x52\x19\x05\xbd\xcf\x45\xcd\xe4\x68\x0c\x1f\x8c\x8a\x62\x58\x4e\x5c\xba\x1d\x78\xfb\xae\x09\xba\xa0\xcf\x26\x3d\xce\x92\x29\xbd\x65\x05\xb8\xa2\xf1\xce\x7d\x7d\xc4\xc6\x00\x2f\xab\x02\x29\x97\x68\x30\x5b\x04\x43\x6b\x1e\xba\x40\x05\x25\x9a\xad\xcc\x4e\x32\x33\xc2\x14\xc5\x10\x7d\xfa\xbc\xd9\x1b\x1c\x3b\xbe\x67\xca\x6d\x44\x4d\x72\x61\x35\x1f\xc5\xb1\xb3\xbf\x8b\xd1\x7f\x8a\xf2\x0e\x8e\x6a\x71\x9a\xa7\xe5\x94\xa9\x23\x74\x91\x3d\xef\xe8\xc7\x8e\x31\xe2\x4b\xf8\x8a\xe5\x3c\xc1\x02\xc5\xc1\xc2\x94\x95\x65\x9e\x76\x4e\x85\x7b\x6c\x63\x80\x80\x9e\x9c\x91\x0c\x63\xaf\x46\xa5\x82\x45\x17\x2c\x96\x0d\x9c\x81\x29\xab\x41\x7e\x27\xeb\xc4\x2a\x52\x41\xa2\x7f\x2b\xec\x8f\xa8\x8b\x82\x0b\x33\xfc\xd7\x46\x75\x5d\xb0\x63\x6a\x1a\x64\x6f\x94\x3a\xe7\xc5\x07\xa3\xe0\xcc\x49\xa3\x93\x73\xbc\x8e\x42\x57\x33\x2b\xc9\x85\x41\x65\xdd\x8f\x17\x61\x0c\xeb\x35\x48\x81\x50\xa1\x72\x65\x27\x97\x0a\xfa\x46\x20\x2d\x98\xde\xa2\xb6\x26\xb8\x48\x99\x98\x6a\x9e\xd6\x04\x21\x23\x94\x39\x4b\x31\x39\xad\x73\x82\x8d\x1c\x0f\x03\x78\xdb\xc5\x10\x91\xa2\x8e\xf2\xa0\x03\x3a\x3b\xe8\xce\x2a\xeb\x46\x44\x0d\x4a\x25\x85\xda\x84\xf7\x0a\xae\x79\x86\xca\x77\x0b\x32\x07\x4d\xfc\xb1\x4d\x81\x56\x34\x9d\x58\xa8\x4c\xf1\x1d\x2a\x5f\xd9\x77\xae\x73\x60\xc6\x79\x92\xac\x6c\xf9\xdd\x22\x14\x5c\x1b\xab\x0b\x6c\x2a\xcc\x38\x8a\x74\x1f\x2c\xf4\x35\x37\xe9\x16\x76\x64\x7d\x57\x44\x23\x42\x6c\x19\x4f\x5d\xb6\x35\x7f\xfb\xeb\xcb\x13\x2c\xef\x62\x0f\xe5\x5c\xca\x81\x39\x6f\x9a\x77\xa6\x5d\xec\x12\xde\xc8\xfa\x94\x62\x66\xbc\x8b\xe4\xa2\x1c\x46\x19\xde\x96\xa8\xad\xd3\xf2\x25\x2a\xaf\x4e\xa6\x87\xbc\x4d\xf0\x4e\xcd\x2b\xd8\x79\x5f\xd6\x46\x51\x9d\x4b\x5e\x19\xc9\xa3\x5d\xfc\x83\xdb\x18\xd9\x60\xcc\xeb\x94\x4d\x56\xf8\x60\x5d\x2c\xc8\xb7\x17\xdd\xd0\xaa\x58\x71\x5d\x68\xdd\x2d\xae\x8f\xb4\x5d\xfc\x8d\xc4\x3e\xd0\x7f\x50\xf1\x8f\xc1\x07\xe7\xd8\x1d\x5c\xe6\x4e\x87\x59\xde\xc4\x41\x92\x78\x06\x2d\x7f\x3e\x8d\x9c\xca\x05\x81\x63\xcd\x52\x59\xf6\xa4\xeb\xfb\xd0\xae\xef\xe7\xd3\x4b\x8f\xeb\x7f\xe0\x6b\x82\x7a\x79\x84\xdb\xb1\xf0\x18\xd8\xf3\x42\x32\x42\x4f\x99\xf0\x57\x2d\x45\x5f\xdc\x34\xe0\x0e\xd5\xde\x6c\x6d\xcf\x43\x7e\xe4\x21\x29\x33\x73\xf3\x3d\xad\x88\xba\xdc\xa0\xba\x53\x37\x0f\x42\xe2\x51\x34\x5b\x3f\xa6\xd9\xea\x47\xb5\xdb\xf2\x90\x46\xbf\x16\xfd\x6d\xd9\x68\xf9\xad\xb2\xef\xf2\xe1\xd2\x6f\x17\x2c\x86\x06\x23\x38\xd9\x55\x68\xd7\x4e\xae\xd7\xe0\x6a\xe2\xa4\xc8\xbb\x7a\xe9\xf6\x66\x4b\xfd\xb4\xd2\x5b\x48\x6a\xf6\xc6\x95\x76\xa6\xe5\x3b\xf4\x7a\xab\xa1\xfd\x71\x9d\xf4\xb7\xe0\xc6\xfa\x6a\xd4\x8c\x78\x19\x5a\x31\xff\xa7\x6f\x95\xf3\x82\x5d\x7a\x16\x2f\xf0\x46\x37\xfa\x56\x16\x4c\x5c\x02\x01\xf9\x1e\x63\x60\x12\x88\xc7\xdb\x5a\x24\x34\x64\xcd\x61\x5c\x1c\x7a\xd1\xdd\xad\x3d\x27\x39\x40\x30\x14\x95\x51\xa3\xe9\x7a\xe7\xb7\xb7\xf3\xf8\x16\x8d\x19\x6b\xf2\x2e\x26\xdf\x22\x35\xf2\xa3\x16\x6e\xa4\xc3\x65\xe3\x69\x7e\xa4\x4e\x72\x42\xf4\x92\x9b\x6d\xbd\x49\x52\x59\xae\x75\x95\xff\xf9\x2f\xeb\xea\xef\xa4\xc8\x89\x8e\x6e\xa1\x4c\x48\xa3\xb8\x1f\x3e\x0f\x54\xc3\xc9\xec\x74\xb2\x8f\x9e\x69\xa1\xc9\x8e\xb6\xed\x3d\xaf\x8b\x62\x32\x31\x69\xa3\xea\xd4\xb4\x34\x83\x8d\xd7\x27\x9f\xc1\xe2\x17\x3b\xc0\x51\x8c\x2e\x36\x52\x16\x6d\xbb\x5e\xc2\xab\x2c\x03\x2d\x4b\x12\x2c\x97\x14\xfe\x46\xc2\xf5\x16\xcd\x96\xda\xec\x2d\xd7\x3e\x2f\x5c\x33\x6d\x6f\x33\xb2\xda\xca\x74\x18\x62\xe8\x4b\x2a\x3b\x21\x2e\xd7\x9d\x1f\xef\x47\x33\xda\xe2\x02\xcd\x62\x31\xa2\x49\x43\x22\xb8\x29\xd1\x2a\xf0\x1c\xaf\x6f\x8a\x64\xbd\xeb\xb8\xfb\x6e\x66\x24\xb7\x61\xd1\x24\x7d\xc7\x6e\x67\x84\x3d\x8d\xbc\xd7\x08\xfc\x52\x48\x85\x4e\x06\xeb\x9f\x2b\xe0\x06\xae\x79\x51\xc0\xaf\xb5\x36\xb0\x41\xa0\x39\x41\xb8\xa9\xd6\x35\xc9\xbd\xa5\xbc\x73\xfc\xb7\x93\xc4\x1c\x83\xf7\x9c\x26\xfc\x55\xd9\x48\x73\x4d\x42\x31\x7b\x06\x46\xd5\x78\xd0\xda\xec\xd8\xd1\x24\xd3\x6b\x82\x26\x71\xb6\x9e\x99\x46\x56\x90\xb3\x42\xe3\x64\x28\x71\x09\x7b\x8a\x28\x39\x70\x1f\x93\xa2\x7b\xa4\xd1\x21\xe9\xc7\x63\x9d\xf9\xbc\x73\x5c\x88\xbe\x3a\x41\xce\xa9\xf3\xce\x24\xc9\x73\x78\xe2\x19\x1d\x4d\xb3\x82\x17\xfd\x2d\xcd\xcd\xd1\x8a\xa5\x29\x56\x46\xbb\xc4\x6a\x47\x29\xe2\xdc\x0d\x5c\xc9\x34\xed\x4e\x34\xf4\xa0\x15\xe1\xb1\x04\x1e\xca\xd8\xd4\xba\x33\x55\xcd\xb9\xd9\xad\x97\x2d\x3f\x5f\xbc\x3f\x87\x54\x2a\x85\xa9\x29\xf6\xa0\x51\x71\x56\xf0\x7f\xd1\x74\x3a\x97\x9d\x8c\x04\x3a\xd1\x8b\x29\x66\xc5\x1c\xa1\x9e\xbf\x7d\x71\x17\xf5\xe4\x56\x17\xf6\xc2\x20\xa4\xbf\xa1\x15\x5f\x78\xbf\x1c\x89\x4f\xbd\x6b\xe2\x71\x46\x62\x6a\xb3\xb1\x52\xfc\x75\x8e\x47\x3c\x7f\x97\x33\x11\x38\xc3\xbb\x44\xce\x95\x2c\x27\x42\xcf\x26\x87\x23\x0a\xd1\x66\xe6\x6e\x67\x94\x04\x82\xc5\x8e\x29\x68\xc6\x69\xc4\xc5\xed\xcb\x33\x27\xef\x80\x2d\xda\xac\xe0\xbb\x66\x7a\xbb\x33\x73\xb9\xe3\xa2\x5e\xb8\x30\x6f\xe2\x49\x4d\x3e\x76\x87\x63\xcf\x60\x22\xfb\x8a\x4a\x45\xa6\x73\xc5\x8a\x84\xbb\xb9\x7f\x7b\x51\xb8\x30\xea\x9e\x75\x81\x2c\xf9\xb8\xa5\xe1\xa1\x02\xdc\x72\xfa\x3b\xc7\xf8\xef\x18\xd8\x56\xbc\x3f\x62\x6c\x5b\xc1\xff\x5f\xc2\xfb\x28\xba\x0f\x33\xc4\xe1\xb5\x74\x78\x8c\x1a\x5e\x4c\x67\x5e\x1a\xc8\x70\x6d\xeb\xbb\x5e\x9e\xef\xdd\x93\x27\x50\x9f\xdb\x7b\x9d\x7b\x10\xe9\xba\x99\xcb\x60\xfb\x56\x61\xfb\x15\xc1\xca\xe1\xb4\x7f\xf9\x9a\x03\x75\xb2\x90\x91\xec\x0d\xa8\xcc\xa1\x92\x5a\xf3\x4d\xd1\x5f\x5b\xf6\x57\xa6\x32\x9f\x9c\xf7\x86\x9b\x41\x1a\xc5\xf0\xe9\xf3\xa1\x6d\x37\x65\x45\xda\x2f\xd9\x15\x46\xfd\xfa\x0a\x0a\x9c\x7f\x68\x89\x69\xde\x97\xd5\x3e\xb2\x57\xef\xb3\x10\x83\x05\x4c\x59\x1d\x2c\x60\x1f\xa7\x67\x54\xf2\x8e\x55\x56\x21\x50\xb2\x6a\xac\x4f\xd7\x9b\xfa\x97\xad\x49\x77\xea\x0d\x75\x9f\x79\xb3\xcf\x0c\xa3\x39\x85\xe7\xf4\x71\xe2\x4d\xec\x1d\xab\x3e\x35\x37\x5e\xbf\xb4\x51\xe3\x90\xcb\x4b\x93\x5c\x54\x8a\x0b\x93\x47\x93\x71\x27\x7a\x96\xc5\xe1\x0a\x9a\x38\x98\x17\xd7\xa5\x54\x2b\x30\x8d\x17\x23\x91\x93\xfe\x51\x0f\x8f\x7c\xf4\x3f\x01\x00\x00\xff\xff\x9f\x4d\x58\xd0\x4a\x20\x00\x00") - -func enumTmplBytes() ([]byte, error) { - return bindataRead( - _enumTmpl, - "enum.tmpl", - ) -} - -func enumTmpl() (*asset, error) { - bytes, err := enumTmplBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "enum.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x93, 0xaa, 0xca, 0xe1, 0xd6, 0x4c, 0x4e, 0x87, 0x6b, 0x96, 0x6, 0xa, 0x6b, 0xcb, 0x25, 0xc1, 0xff, 0xb2, 0x79, 0xe3, 0x66, 0x2f, 0xd, 0x43, 0x6b, 0x41, 0xea, 0x4d, 0xb1, 0x67, 0x76, 0xbe}} - return a, nil -} - -// Asset loads and returns the asset for the given name. -// It returns an error if the asset could not be found or -// could not be loaded. -func Asset(name string) ([]byte, error) { - canonicalName := strings.Replace(name, "\\", "/", -1) - if f, ok := _bindata[canonicalName]; ok { - a, err := f() - if err != nil { - return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) - } - return a.bytes, nil - } - return nil, fmt.Errorf("Asset %s not found", name) -} - -// AssetString returns the asset contents as a string (instead of a []byte). -func AssetString(name string) (string, error) { - data, err := Asset(name) - return string(data), err -} - -// MustAsset is like Asset but panics when Asset would return an error. -// It simplifies safe initialization of global variables. -func MustAsset(name string) []byte { - a, err := Asset(name) - if err != nil { - panic("asset: Asset(" + name + "): " + err.Error()) - } - - return a -} - -// MustAssetString is like AssetString but panics when Asset would return an -// error. It simplifies safe initialization of global variables. -func MustAssetString(name string) string { - return string(MustAsset(name)) -} - -// AssetInfo loads and returns the asset info for the given name. -// It returns an error if the asset could not be found or -// could not be loaded. -func AssetInfo(name string) (os.FileInfo, error) { - canonicalName := strings.Replace(name, "\\", "/", -1) - if f, ok := _bindata[canonicalName]; ok { - a, err := f() - if err != nil { - return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) - } - return a.info, nil - } - return nil, fmt.Errorf("AssetInfo %s not found", name) -} - -// AssetDigest returns the digest of the file with the given name. It returns an -// error if the asset could not be found or the digest could not be loaded. -func AssetDigest(name string) ([sha256.Size]byte, error) { - canonicalName := strings.Replace(name, "\\", "/", -1) - if f, ok := _bindata[canonicalName]; ok { - a, err := f() - if err != nil { - return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s can't read by error: %v", name, err) - } - return a.digest, nil - } - return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s not found", name) -} - -// Digests returns a map of all known files and their checksums. -func Digests() (map[string][sha256.Size]byte, error) { - mp := make(map[string][sha256.Size]byte, len(_bindata)) - for name := range _bindata { - a, err := _bindata[name]() - if err != nil { - return nil, err - } - mp[name] = a.digest - } - return mp, nil -} - -// AssetNames returns the names of the assets. -func AssetNames() []string { - names := make([]string, 0, len(_bindata)) - for name := range _bindata { - names = append(names, name) - } - return names -} - -// _bindata is a table, holding each asset generator, mapped to its name. -var _bindata = map[string]func() (*asset, error){ - "enum.tmpl": enumTmpl, -} - -// AssetDebug is true if the assets were built with the debug flag enabled. -const AssetDebug = false - -// AssetDir returns the file names below a certain -// directory embedded in the file by go-bindata. -// For example if you run go-bindata on data/... and data contains the -// following hierarchy: -// data/ -// foo.txt -// img/ -// a.png -// b.png -// then AssetDir("data") would return []string{"foo.txt", "img"}, -// AssetDir("data/img") would return []string{"a.png", "b.png"}, -// AssetDir("foo.txt") and AssetDir("notexist") would return an error, and -// AssetDir("") will return []string{"data"}. -func AssetDir(name string) ([]string, error) { - node := _bintree - if len(name) != 0 { - canonicalName := strings.Replace(name, "\\", "/", -1) - pathList := strings.Split(canonicalName, "/") - for _, p := range pathList { - node = node.Children[p] - if node == nil { - return nil, fmt.Errorf("Asset %s not found", name) - } - } - } - if node.Func != nil { - return nil, fmt.Errorf("Asset %s not found", name) - } - rv := make([]string, 0, len(node.Children)) - for childName := range node.Children { - rv = append(rv, childName) - } - return rv, nil -} - -type bintree struct { - Func func() (*asset, error) - Children map[string]*bintree -} - -var _bintree = &bintree{nil, map[string]*bintree{ - "enum.tmpl": {enumTmpl, map[string]*bintree{}}, -}} - -// RestoreAsset restores an asset under the given directory. -func RestoreAsset(dir, name string) error { - data, err := Asset(name) - if err != nil { - return err - } - info, err := AssetInfo(name) - if err != nil { - return err - } - err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) - if err != nil { - return err - } - err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) - if err != nil { - return err - } - return os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) -} - -// RestoreAssets restores an asset under the given directory recursively. -func RestoreAssets(dir, name string) error { - children, err := AssetDir(name) - // File - if err != nil { - return RestoreAsset(dir, name) - } - // Dir - for _, child := range children { - err = RestoreAssets(dir, filepath.Join(name, child)) - if err != nil { - return err - } - } - return nil -} - -func _filePath(dir, name string) string { - canonicalName := strings.Replace(name, "\\", "/", -1) - return filepath.Join(append([]string{dir}, strings.Split(canonicalName, "/")...)...) -} diff --git a/generator/embedded_1.16.go b/generator/embedded_1.16.go new file mode 100644 index 00000000..ea64de94 --- /dev/null +++ b/generator/embedded_1.16.go @@ -0,0 +1,16 @@ +//go:build go1.16 +// +build go1.16 + +package generator + +import ( + "embed" + "text/template" +) + +//go:embed enum.tmpl enum_string.tmpl +var content embed.FS + +func (g *Generator) addEmbeddedTemplates() { + g.t = template.Must(g.t.ParseFS(content, "*.tmpl")) +} diff --git a/generator/enum.tmpl b/generator/enum.tmpl index 6a025af6..d96d6d22 100644 --- a/generator/enum.tmpl +++ b/generator/enum.tmpl @@ -1,31 +1,66 @@ {{- define "header"}} -// Code generated by go-enum -// DO NOT EDIT! +// Code generated by go-enum DO NOT EDIT. +// Version: {{ .version }} +// Revision: {{ .revision }} +// Build Date: {{ .buildDate }} +// Built By: {{ .builtBy }} +{{ range $idx, $tag := .buildTags }} +//go:build {{$tag}} +// +build {{$tag}} +{{- end }} package {{.package}} import ( "fmt" + json "{{.jsonpkg}}" ) {{end -}} {{- define "enum"}} const ( {{- $enumName := .enum.Name -}} -{{- $vars := dict "lastoffset" 0 -}} +{{- $enumType := .enum.Type -}} +{{- $noComments := .nocomments -}} +{{- $vars := dict "lastoffset" "0" -}} {{ range $rIndex, $value := .enum.Values }} - {{- $lastOffset := pluck "lastoffset" $vars | first }}{{ $offset := sub $value.Value $rIndex }} - {{ if eq $value.Name "_"}}// Skipped value.{{else}}// {{$value.PrefixedName}} is a {{$enumName}} of type {{$value.Name}}.{{end}} + {{- $lastOffset := pluck "lastoffset" $vars | first }}{{ $offset := offset $rIndex $enumType $value }} + {{- if $noComments }}{{else}} + {{ if eq $value.Name "_"}}// Skipped value.{{else}}// {{$value.PrefixedName}} is a {{$enumName}} of type {{$value.Name}}.{{end}}{{end}} {{- if $value.Comment}} // {{$value.Comment}} {{- end}} - {{$value.PrefixedName}} {{ if eq $rIndex 0 }}{{$enumName}} = iota{{ if ne 0 $offset }} + {{ $offset }}{{end}}{{else if ne $lastOffset $offset }}{{$enumName}} = iota + {{ $offset }}{{end}}{{$_ := set $vars "lastoffset" $offset}} + {{$value.PrefixedName}} {{ if eq $rIndex 0 }}{{$enumName}} = iota{{ if ne "0" $offset }} + {{ $offset }}{{end}}{{else if ne $lastOffset $offset }}{{$enumName}} = iota + {{ $offset }}{{end}}{{$_ := set $vars "lastoffset" $offset}} {{- end}} ) +{{if .names -}} +var ErrInvalid{{.enum.Name}} = fmt.Errorf("not a valid {{.enum.Name}}, try [%s]", strings.Join(_{{.enum.Name}}Names, ", ")) +{{- else -}} +var ErrInvalid{{.enum.Name}} = errors.New("not a valid {{.enum.Name}}") +{{- end}} {{ template "stringer" . }} -// Parse{{.enum.Name}} attempts to convert a string to a {{.enum.Name}} +var _{{.enum.Name}}Map = {{ mapify .enum }} + +// String implements the Stringer interface. +func (x {{.enum.Name}}) String() string { + if str, ok := _{{.enum.Name}}Map[x]; ok { + return str + } + return fmt.Sprintf("{{.enum.Name}}(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x {{.enum.Name}}) IsValid() bool { + _, ok := _{{.enum.Name}}Map[x] + return ok +} + +var _{{.enum.Name}}Value = {{ unmapify .enum .lowercase }} + +// Parse{{.enum.Name}} attempts to convert a string to a {{.enum.Name}}. func Parse{{.enum.Name}}(name string) ({{.enum.Name}}, error) { if x, ok := _{{.enum.Name}}Value[name]; ok { return x, nil @@ -34,13 +69,20 @@ func Parse{{.enum.Name}}(name string) ({{.enum.Name}}, error) { if x, ok := _{{.enum.Name}}Value[strings.ToLower(name)]; ok { return x, nil }{{- end}} - {{if .names -}} - return {{.enum.Name}}(0), fmt.Errorf("%s is not a valid {{.enum.Name}}, try [%s]", name, strings.Join(_{{.enum.Name}}Names, ", ")) - {{- else -}} - return {{.enum.Name}}(0), fmt.Errorf("%s is not a valid {{.enum.Name}}", name) - {{- end}} + return {{.enum.Name}}(0), fmt.Errorf("%s is %w", name, ErrInvalid{{.enum.Name}}) } +{{ if .mustparse }} +// MustParse{{.enum.Name}} converts a string to a {{.enum.Name}}, and panics if is not valid. +func MustParse{{.enum.Name}}(name string) {{.enum.Name}} { + val, err := Parse{{.enum.Name}}(name) + if err != nil { + panic(err) + } + return val +} +{{end}} + {{ if .ptr }} func (x {{.enum.Name}}) Ptr() *{{.enum.Name}} { return &x @@ -48,12 +90,12 @@ func (x {{.enum.Name}}) Ptr() *{{.enum.Name}} { {{end}} {{ if .marshal }} -// MarshalText implements the text marshaller method +// MarshalText implements the text marshaller method. func (x {{.enum.Name}}) MarshalText() ([]byte, error) { return []byte(x.String()), nil } -// UnmarshalText implements the text unmarshaller method +// UnmarshalText implements the text unmarshaller method. func (x *{{.enum.Name}}) UnmarshalText(text []byte) error { name := string(text) tmp, err := Parse{{.enum.Name}}(name) @@ -66,7 +108,7 @@ func (x *{{.enum.Name}}) UnmarshalText(text []byte) error { {{end}} {{ if or .sql .sqlnullint .sqlnullstr}} -var _{{.enum.Name}}ErrNilPtr = errors.New("value pointer is nil") // one per type for package clashes +var err{{.enum.Name}}NilPtr = errors.New("value pointer is nil") // one per type for package clashes // Scan implements the Scanner interface. func (x *{{.enum.Name}}) Scan(value interface{}) (err error) { @@ -102,7 +144,7 @@ func (x *{{.enum.Name}}) Scan(value interface{}) (err error) { *x = {{.enum.Name}}(v) case *{{.enum.Name}}: if v == nil{ - return _{{.enum.Name}}ErrNilPtr + return err{{.enum.Name}}NilPtr } *x = *v case uint: @@ -111,34 +153,34 @@ func (x *{{.enum.Name}}) Scan(value interface{}) (err error) { *x = {{.enum.Name}}(v) case *int: if v == nil{ - return _{{.enum.Name}}ErrNilPtr + return err{{.enum.Name}}NilPtr } *x = {{.enum.Name}}(*v) case *int64: if v == nil{ - return _{{.enum.Name}}ErrNilPtr + return err{{.enum.Name}}NilPtr } *x = {{.enum.Name}}(*v) case float64: // json marshals everything as a float64 if it's a number *x = {{.enum.Name}}(v) case *float64: // json marshals everything as a float64 if it's a number if v == nil{ - return _{{.enum.Name}}ErrNilPtr + return err{{.enum.Name}}NilPtr } *x = {{.enum.Name}}(*v) case *uint: if v == nil{ - return _{{.enum.Name}}ErrNilPtr + return err{{.enum.Name}}NilPtr } *x = {{.enum.Name}}(*v) case *uint64: if v == nil{ - return _{{.enum.Name}}ErrNilPtr + return err{{.enum.Name}}NilPtr } *x = {{.enum.Name}}(*v) case *string: if v == nil{ - return _{{.enum.Name}}ErrNilPtr + return err{{.enum.Name}}NilPtr } *x, err = Parse{{.enum.Name}}(*v){{if .sqlnullint }} if err != nil { @@ -300,7 +342,7 @@ func (n *Null{{.enum.Name}}Str) UnmarshalJSON(b []byte) error { {{- define "stringer"}} -const _{{.enum.Name}}Name = "{{ stringify .enum }}" + const _{{.enum.Name}}Name = "{{ stringify .enum .forcelower .forceupper }}" {{ if .names }}var _{{.enum.Name}}Names = {{namify .enum}} @@ -312,16 +354,15 @@ func {{.enum.Name}}Names() []string { } {{ end -}} -var _{{.enum.Name}}Map = {{ mapify .enum }} +{{ if .values }} -// String implements the Stringer interface. -func (x {{.enum.Name}}) String() string { - if str, ok := _{{.enum.Name}}Map[x]; ok { - return str - } - return fmt.Sprintf("{{.enum.Name}}(%d)", x) +// {{.enum.Name}}Values returns a list of the values for {{.enum.Name}} +func {{.enum.Name}}Values() []{{.enum.Name}} { + return []{{.enum.Name}}{ {{ range $rIndex, $value := .enum.Values }}{{ if ne $value.Name "_"}} + {{$value.PrefixedName}},{{ end }} +{{- end}} + } } - -var _{{.enum.Name}}Value = {{ unmapify .enum .lowercase }} +{{ end -}} {{end}} diff --git a/generator/enum_string.tmpl b/generator/enum_string.tmpl new file mode 100644 index 00000000..4fbb096f --- /dev/null +++ b/generator/enum_string.tmpl @@ -0,0 +1,384 @@ +{{- define "enum_string"}} +const ( +{{- $enumName := .enum.Name -}} +{{- $enumType := .enum.Type -}} +{{- $noComments := .nocomments -}} +{{- $vars := dict "lastoffset" "0" -}} +{{ range $rIndex, $value := .enum.Values }} + {{- if $noComments }}{{else}} + {{ if eq $value.Name "_"}}// Skipped value.{{else}}// {{$value.PrefixedName}} is a {{$enumName}} of type {{$value.RawName}}.{{end}}{{end}} + {{- if $value.Comment}} + // {{$value.Comment}} + {{- end}} + {{$value.PrefixedName}} {{$enumName}} = {{quote $value.ValueStr}} +{{- end}} +) +{{if .names -}} +var ErrInvalid{{.enum.Name}} = fmt.Errorf("not a valid {{.enum.Name}}, try [%s]", strings.Join(_{{.enum.Name}}Names, ", ")) +{{- else -}} +var ErrInvalid{{.enum.Name}} = errors.New("not a valid {{.enum.Name}}") +{{- end}} + +{{ if .names }}var _{{.enum.Name}}Names = {{namify .enum}} + +// {{.enum.Name}}Names returns a list of possible string values of {{.enum.Name}}. +func {{.enum.Name}}Names() []string { + tmp := make([]string, len(_{{.enum.Name}}Names)) + copy(tmp, _{{.enum.Name}}Names) + return tmp +} +{{ end -}} + + +{{ if .values }} + +// {{.enum.Name}}Values returns a list of the values for {{.enum.Name}} +func {{.enum.Name}}Values() []{{.enum.Name}} { + return []{{.enum.Name}}{ {{ range $rIndex, $value := .enum.Values }}{{ if ne $value.Name "_"}} + {{$value.PrefixedName}},{{ end }} +{{- end}} + } +} +{{ end -}} + +// String implements the Stringer interface. +func (x {{.enum.Name}}) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x {{.enum.Name}}) IsValid() bool { + _, err := Parse{{.enum.Name}}(string(x)) + return err == nil +} + +var _{{.enum.Name}}Value = {{ unmapify .enum .lowercase }} + +// Parse{{.enum.Name}} attempts to convert a string to a {{.enum.Name}}. +func Parse{{.enum.Name}}(name string) ({{.enum.Name}}, error) { + if x, ok := _{{.enum.Name}}Value[name]; ok { + return x, nil + }{{if .nocase }} + // Case insensitive parse, do a separate lookup to prevent unnecessary cost of lowercasing a string if we don't need to. + if x, ok := _{{.enum.Name}}Value[strings.ToLower(name)]; ok { + return x, nil + }{{- end}} + return {{.enum.Name}}(""), fmt.Errorf("%s is %w", name, ErrInvalid{{.enum.Name}}) +} + +{{ if .mustparse }} +// MustParse{{.enum.Name}} converts a string to a {{.enum.Name}}, and panics if is not valid. +func MustParse{{.enum.Name}}(name string) {{.enum.Name}} { + val, err := Parse{{.enum.Name}}(name) + if err != nil { + panic(err) + } + return val +} +{{end}} + +{{ if .ptr }} +func (x {{.enum.Name}}) Ptr() *{{.enum.Name}} { + return &x +} +{{end}} + +{{ if .marshal }} +// MarshalText implements the text marshaller method. +func (x {{.enum.Name}}) MarshalText() ([]byte, error) { + return []byte(string(x)), nil +} + +// UnmarshalText implements the text unmarshaller method. +func (x *{{.enum.Name}}) UnmarshalText(text []byte) error { + tmp, err := Parse{{.enum.Name}}(string(text)) + if err != nil { + return err + } + *x = tmp + return nil +} +{{end}} + +{{ if .anySQLEnabled }} +var err{{.enum.Name}}NilPtr = errors.New("value pointer is nil") // one per type for package clashes +{{ end }} + +{{/* SQL stored as a string value */}} +{{ if or .sql .sqlnullstr }} + +// Scan implements the Scanner interface. +func (x *{{.enum.Name}}) Scan(value interface{}) (err error) { + if value == nil { + *x = {{.enum.Name}}("") + return + } + + // A wider range of scannable types. + // driver.Value values at the top of the list for expediency + switch v := value.(type) { + case string: + *x, err = Parse{{.enum.Name}}(v) + case []byte: + *x, err = Parse{{.enum.Name}}(string(v)) + case {{.enum.Name}}: + *x = v + case *{{.enum.Name}}: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x = *v + case *string: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x, err = Parse{{.enum.Name}}(*v) + default: + return errors.New("invalid type for {{.enum.Name}}") + } + + return +} + +// Value implements the driver Valuer interface. +func (x {{.enum.Name}}) Value() (driver.Value, error) { + return x.String(), nil +} +{{end}} + +{{/* SQL stored as an integer value */}} +{{ if or .sqlint .sqlnullint }} +var sqlInt{{.enum.Name}}Map = map[int64]{{.enum.Name}}{ {{ range $rIndex, $value := .enum.Values }}{{ if ne $value.Name "_"}} +{{ $value.ValueInt }}: {{ $value.PrefixedName }},{{end}} +{{- end}} +} + +var sqlInt{{.enum.Name}}Value = map[{{.enum.Name}}]int64{ {{ range $rIndex, $value := .enum.Values }}{{ if ne $value.Name "_"}} + {{ $value.PrefixedName }}: {{ $value.ValueInt }},{{end}} +{{- end}} +} + +func lookupSqlInt{{.enum.Name}}(val int64) ({{.enum.Name}}, error){ + x, ok := sqlInt{{.enum.Name}}Map[val] + if !ok{ + return x, fmt.Errorf("%v is not %w", val, ErrInvalid{{.enum.Name}}) + } + return x, nil +} + +// Scan implements the Scanner interface. +func (x *{{.enum.Name}}) Scan(value interface{}) (err error) { + if value == nil { + *x = {{.enum.Name}}("") + return + } + + // A wider range of scannable types. + // driver.Value values at the top of the list for expediency + switch v := value.(type) { + case int64: + *x, err = lookupSqlInt{{.enum.Name}}(v) + case string: + *x, err = Parse{{.enum.Name}}(v) + case []byte: + if val, verr := strconv.ParseInt(string(v), 10, 64); verr == nil { + *x, err = lookupSqlInt{{.enum.Name}}(val) + } else { + // try parsing the value as a string + *x, err = Parse{{.enum.Name}}(string(v)) + } + case {{.enum.Name}}: + *x = v + case int: + *x, err = lookupSqlInt{{.enum.Name}}(int64(v)) + case *{{.enum.Name}}: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x = *v + case uint: + *x, err = lookupSqlInt{{.enum.Name}}(int64(v)) + case uint64: + *x, err = lookupSqlInt{{.enum.Name}}(int64(v)) + case *int: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x, err = lookupSqlInt{{.enum.Name}}(int64(*v)) + case *int64: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x, err = lookupSqlInt{{.enum.Name}}(int64(*v)) + case float64: // json marshals everything as a float64 if it's a number + *x, err = lookupSqlInt{{.enum.Name}}(int64(v)) + case *float64: // json marshals everything as a float64 if it's a number + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x, err = lookupSqlInt{{.enum.Name}}(int64(*v)) + case *uint: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x, err = lookupSqlInt{{.enum.Name}}(int64(*v)) + case *uint64: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x, err = lookupSqlInt{{.enum.Name}}(int64(*v)) + case *string: + if v == nil{ + return err{{.enum.Name}}NilPtr + } + *x, err = Parse{{.enum.Name}}(*v) + default: + return errors.New("invalid type for {{.enum.Name}}") + } + + return +} + +// Value implements the driver Valuer interface. +func (x {{.enum.Name}}) Value() (driver.Value, error) { + val, ok := sqlInt{{.enum.Name}}Value[x] + if !ok{ + return nil, ErrInvalid{{.enum.Name}} + } + return int64(val), nil +} + +{{end}} + + +{{ if .flag }} +// Set implements the Golang flag.Value interface func. +func (x *{{.enum.Name}}) Set(val string) error { + v, err := Parse{{.enum.Name}}(val) + *x = v + return err +} + +// Get implements the Golang flag.Getter interface func. +func (x *{{.enum.Name}}) Get() interface{} { + return *x +} + +// Type implements the github.com/spf13/pFlag Value interface. +func (x *{{.enum.Name}}) Type() string { + return "{{.enum.Name}}" +} +{{end}} + +{{ if or .sqlnullint .sqlnullstr }} +type Null{{.enum.Name}} struct{ + {{.enum.Name}} {{.enum.Name}} + Valid bool{{/* Add some info as to whether this value was set during unmarshalling or not */}}{{if .marshal }} + Set bool{{ end }} +} + +func NewNull{{.enum.Name}}(val interface{}) (x Null{{.enum.Name}}) { + err := x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + _ = err // make any errcheck linters happy + return +} + +// Scan implements the Scanner interface. +func (x *Null{{.enum.Name}}) Scan(value interface{}) (err error) { + if value == nil { + x.{{.enum.Name}}, x.Valid = {{.enum.Name}}(""), false + return + } + + err = x.{{.enum.Name}}.Scan(value) + x.Valid = (err == nil) + return +} + +{{ if .sqlnullint }} +// Value implements the driver Valuer interface. +func (x Null{{.enum.Name}}) Value() (driver.Value, error) { + if !x.Valid{ + return nil, nil + } + // driver.Value accepts int64 for int values. + return string(x.{{.enum.Name}}), nil +} +{{ else }} +// Value implements the driver Valuer interface. +func (x Null{{.enum.Name}}) Value() (driver.Value, error) { + if !x.Valid{ + return nil, nil + } + return x.{{.enum.Name}}.String(), nil +} +{{ end }} + +{{ if .marshal }} +// MarshalJSON correctly serializes a Null{{.enum.Name}} to JSON. +func (n Null{{.enum.Name}}) MarshalJSON() ([]byte, error) { + const nullStr = "null" + if n.Valid { + return json.Marshal(n.{{.enum.Name}}) + } + return []byte(nullStr), nil +} + +// UnmarshalJSON correctly deserializes a Null{{.enum.Name}} from JSON. +func (n *Null{{.enum.Name}}) UnmarshalJSON(b []byte) error { + n.Set = true + var x interface{} + err := json.Unmarshal(b, &x) + if err != nil{ + return err + } + err = n.Scan(x) + return err +} +{{ end }} + +{{ end }} + +{{ if and .sqlnullint .sqlnullstr }} +type Null{{.enum.Name}}Str struct { + Null{{.enum.Name}} +} + +func NewNull{{.enum.Name}}Str(val interface{}) (x Null{{.enum.Name}}Str) { + x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + return +} + +// Value implements the driver Valuer interface. +func (x Null{{.enum.Name}}Str) Value() (driver.Value, error) { + if !x.Valid{ + return nil, nil + } + return x.{{.enum.Name}}.String(), nil +} +{{ if .marshal }} +// MarshalJSON correctly serializes a Null{{.enum.Name}} to JSON. +func (n Null{{.enum.Name}}Str) MarshalJSON() ([]byte, error) { + const nullStr = "null" + if n.Valid { + return json.Marshal(n.{{.enum.Name}}) + } + return []byte(nullStr), nil +} + +// UnmarshalJSON correctly deserializes a Null{{.enum.Name}} from JSON. +func (n *Null{{.enum.Name}}Str) UnmarshalJSON(b []byte) error { + n.Set = true + var x interface{} + err := json.Unmarshal(b, &x) + if err != nil{ + return err + } + err = n.Scan(x) + return err +} +{{ end }} +{{ end }} + +{{end}} diff --git a/generator/example_1.18_test.go b/generator/example_1.18_test.go new file mode 100644 index 00000000..dbf66582 --- /dev/null +++ b/generator/example_1.18_test.go @@ -0,0 +1,22 @@ +//go:build go1.18 +// +build go1.18 + +package generator + +// SumIntsOrFloats sums the values of map m. It supports both int64 and float64 +// as types for map values. +func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V { + var s V + for _, v := range m { + s += v + } + return s +} + +// ChangeType is a type of change detected. +/* ENUM( + Create + Update + Delete +) */ +type ChangeType int diff --git a/generator/example_test.go b/generator/example_test.go index 535aa843..c5433d97 100644 --- a/generator/example_test.go +++ b/generator/example_test.go @@ -11,50 +11,58 @@ type X struct { // Blue=33 // grey= // yellow -// ) +// ). type Color int // Animal x ENUM( // Cat, // Dog, // Fish -// ) +// ) Some other line of info type Animal int32 -// Model x ENUM(Toyota,_,Chevy,_,Ford) +// Model x ENUM(Toyota,_,Chevy,_,Ford). type Model int32 -/* ENUM( - Coke - Pepsi - MtnDew -) +/* + ENUM( + Coke + Pepsi + MtnDew + +). */ type Soda int64 -/* ENUM( - test_lower - Test_capital - anotherLowerCaseStart +/* + ENUM( + test_lower + Test_capital + anotherLowerCaseStart + ) */ type Cases int64 -/* ENUM( - test-Hyphen - -hyphenStart - _underscoreFirst - 0numberFirst - 123456789a - 123123-asdf - ending-hyphen- +/* + ENUM( + test-Hyphen + -hyphenStart + _underscoreFirst + 0numberFirst + 123456789a + 123123-asdf + ending-hyphen- + ) */ type Sanitizing int64 -/* ENUM( - startWithNum=23 - nextNum +/* + ENUM( + startWithNum=23 + nextNum + ) */ type StartNotZero int64 @@ -62,19 +70,21 @@ type StartNotZero int64 // ENUM( // Black, White, Red // Green -// Blue=33 // Blue starts with 33 +// Blue=33 // Blue starts with 33. // grey= // yellow // ) type ColorWithComment int -/*ENUM( +/* +ENUM( Black, White, Red Green Blue=33 // Blue starts with 33 grey= yellow -)*/ +) +*/ type ColorWithComment2 int /* ENUM( @@ -102,3 +112,41 @@ Green = 33 // Green starts with 33 // red-orange // has a , in it!?! // ) type ColorWithComment4 int + +/* + ENUM( + +Unknown= 0 +E2P15 = 32768 +E2P16 = 65536 +E2P17 = 131072 +E2P18 = 262144 +E2P19 = 524288 +E2P20 = 1048576 +E2P21 = 2097152 +E2P22 = 33554432 +E2P23 = 67108864 +E2P28 = 536870912 +E2P30 = 1073741824 +E2P31 = 2147483648 +E2P32 = 4294967296 +E2P33 = 8454967296 +) +*/ +type Enum64bit uint64 + +// NonASCII +// ENUM( +// Продам = 1114 +// 車庫 = 300 +// էժան = 1 +// ) +type NonASCII int + +// StringEnum. +// ENUM( +// random = 1114 +// values = 300 +// here = 1 +// ) +type StringEnum string diff --git a/generator/generator.go b/generator/generator.go index db814980..61fd6ac3 100644 --- a/generator/generator.go +++ b/generator/generator.go @@ -1,9 +1,8 @@ -//go:generate ../bin/go-bindata -nometadata -o assets/assets.go -pkg=assets enum.tmpl - package generator import ( "bytes" + "errors" "fmt" "go/ast" "go/parser" @@ -15,9 +14,9 @@ import ( "text/template" "unicode" - "github.com/Masterminds/sprig" - "github.com/abice/go-enum/generator/assets" - "github.com/pkg/errors" + "github.com/Masterminds/sprig/v3" + "golang.org/x/text/cases" + "golang.org/x/text/language" "golang.org/x/tools/imports" ) @@ -28,6 +27,10 @@ const ( // Generator is responsible for generating validation files for the given in a go source file. type Generator struct { + Version string + Revision string + BuildDate string + BuiltBy string t *template.Template knownTemplates map[string]*template.Template userTemplateNames []string @@ -37,21 +40,31 @@ type Generator struct { caseInsensitive bool marshal bool sql bool + sqlint bool flag bool names bool + values bool leaveSnakeCase bool + jsonPkg string prefix string sqlNullInt bool sqlNullStr bool ptr bool + mustParse bool + forceLower bool + forceUpper bool + noComments bool + buildTags []string + replacementNames map[string]string } // Enum holds data for a discovered enum in the parsed source type Enum struct { - Name string - Prefix string - Type string - Values []EnumValue + Name string + Prefix string + Type string + Values []EnumValue + Comment string } // EnumValue holds the individual data for each enum value within the found enum. @@ -59,7 +72,8 @@ type EnumValue struct { RawName string Name string PrefixedName string - Value int + ValueStr string + ValueInt interface{} Comment string } @@ -67,11 +81,17 @@ type EnumValue struct { // templates loaded. func NewGenerator() *Generator { g := &Generator{ + Version: "-", + Revision: "-", + BuildDate: "-", + BuiltBy: "-", knownTemplates: make(map[string]*template.Template), userTemplateNames: make([]string, 0), t: template.New("generator"), fileSet: token.NewFileSet(), noPrefix: false, + replacementNames: map[string]string{}, + jsonPkg: "encoding/json", } funcs := sprig.TxtFuncMap() @@ -80,12 +100,12 @@ func NewGenerator() *Generator { funcs["mapify"] = Mapify funcs["unmapify"] = Unmapify funcs["namify"] = Namify + funcs["offset"] = Offset + funcs["quote"] = strconv.Quote g.t.Funcs(funcs) - for _, asset := range assets.AssetNames() { - g.t = template.Must(g.t.Parse(string(assets.MustAsset(asset)))) - } + g.addEmbeddedTemplates() g.updateTemplates() @@ -123,6 +143,12 @@ func (g *Generator) WithSQLDriver() *Generator { return g } +// WithSQLInt is used to signal a string to be stored as an int. +func (g *Generator) WithSQLInt() *Generator { + g.sqlint = true + return g +} + // WithFlag is used to add flag methods to the enum func (g *Generator) WithFlag() *Generator { g.flag = true @@ -135,12 +161,24 @@ func (g *Generator) WithNames() *Generator { return g } +// WithValues is used to add Values methods to the enum +func (g *Generator) WithValues() *Generator { + g.values = true + return g +} + // WithoutSnakeToCamel is used to add flag methods to the enum func (g *Generator) WithoutSnakeToCamel() *Generator { g.leaveSnakeCase = true return g } +// WithJsonPkg is used to add a custom json package to the imports +func (g *Generator) WithJsonPkg(pkg string) *Generator { + g.jsonPkg = pkg + return g +} + // WithPrefix is used to add a custom prefix to the enum constants func (g *Generator) WithPrefix(prefix string) *Generator { g.prefix = prefix @@ -165,6 +203,67 @@ func (g *Generator) WithSQLNullStr() *Generator { return g } +// WithMustParse is used to add a method `MustParse` that will panic on failure. +func (g *Generator) WithMustParse() *Generator { + g.mustParse = true + return g +} + +// WithForceLower is used to force enums names to lower case while keeping variable names the same. +func (g *Generator) WithForceLower() *Generator { + g.forceLower = true + return g +} + +// WithForceUpper is used to force enums names to upper case while keeping variable names the same. +func (g *Generator) WithForceUpper() *Generator { + g.forceUpper = true + return g +} + +// WithNoComments is used to remove auto generated comments from the enum. +func (g *Generator) WithNoComments() *Generator { + g.noComments = true + return g +} + +// WithBuildTags will add build tags to the generated file. +func (g *Generator) WithBuildTags(tags ...string) *Generator { + g.buildTags = append(g.buildTags, tags...) + return g +} + +// WithAliases will set up aliases for the generator. +func (g *Generator) WithAliases(aliases map[string]string) *Generator { + if aliases == nil { + return g + } + g.replacementNames = aliases + return g +} + +func (g *Generator) anySQLEnabled() bool { + return g.sql || g.sqlNullStr || g.sqlint || g.sqlNullInt +} + +// ParseAliases is used to add aliases to replace during name sanitization. +func ParseAliases(aliases []string) (map[string]string, error) { + aliasMap := map[string]string{} + + for _, str := range aliases { + kvps := strings.Split(str, ",") + for _, kvp := range kvps { + parts := strings.Split(kvp, ":") + if len(parts) != 2 { + return nil, fmt.Errorf("invalid formatted alias entry %q, must be in the format \"key:value\"", kvp) + } + aliasMap[parts[0]] = parts[1] + } + } + + return aliasMap, nil +} + // WithTemplates is used to provide the filenames of additional templates. func (g *Generator) WithTemplates(filenames ...string) *Generator { for _, ut := range template.Must(g.t.ParseFiles(filenames...)).Templates() { @@ -185,7 +284,6 @@ func (g *Generator) GenerateFromFile(inputFile string) ([]byte, error) { return nil, fmt.Errorf("generate: error parsing input file '%s': %s", inputFile, err) } return g.Generate(f) - } // Generate does the heavy lifting for the code generation starting from the parsed AST file. @@ -198,9 +296,17 @@ func (g *Generator) Generate(f *ast.File) ([]byte, error) { pkg := f.Name.Name vBuff := bytes.NewBuffer([]byte{}) - err := g.t.ExecuteTemplate(vBuff, "header", map[string]interface{}{"package": pkg}) + err := g.t.ExecuteTemplate(vBuff, "header", map[string]interface{}{ + "package": pkg, + "version": g.Version, + "revision": g.Revision, + "buildDate": g.BuildDate, + "builtBy": g.BuiltBy, + "buildTags": g.buildTags, + "jsonpkg": g.jsonPkg, + }) if err != nil { - return nil, errors.WithMessage(err, "Failed writing header") + return nil, fmt.Errorf("failed writing header: %w", err) } // Make the output more consistent by iterating over sorted keys of map @@ -210,6 +316,7 @@ func (g *Generator) Generate(f *ast.File) ([]byte, error) { } sort.Strings(keys) + var created int for _, name := range keys { ts := enums[name] @@ -219,33 +326,51 @@ func (g *Generator) Generate(f *ast.File) ([]byte, error) { continue } + created++ data := map[string]interface{}{ - "enum": enum, - "name": name, - "lowercase": g.lowercaseLookup, - "nocase": g.caseInsensitive, - "marshal": g.marshal, - "sql": g.sql, - "flag": g.flag, - "names": g.names, - "ptr": g.ptr, - "sqlnullint": g.sqlNullInt, - "sqlnullstr": g.sqlNullStr, + "enum": enum, + "name": name, + "lowercase": g.lowercaseLookup, + "nocase": g.caseInsensitive, + "nocomments": g.noComments, + "marshal": g.marshal, + "sql": g.sql, + "sqlint": g.sqlint, + "flag": g.flag, + "names": g.names, + "ptr": g.ptr, + "values": g.values, + "anySQLEnabled": g.anySQLEnabled(), + "sqlnullint": g.sqlNullInt, + "sqlnullstr": g.sqlNullStr, + "mustparse": g.mustParse, + "forcelower": g.forceLower, + "forceupper": g.forceUpper, } - err = g.t.ExecuteTemplate(vBuff, "enum", data) + templateName := "enum" + if enum.Type == "string" { + templateName = "enum_string" + } + + err = g.t.ExecuteTemplate(vBuff, templateName, data) if err != nil { - return vBuff.Bytes(), errors.WithMessage(err, fmt.Sprintf("Failed writing enum data for enum: %q", name)) + return vBuff.Bytes(), fmt.Errorf("failed writing enum data for enum: %q: %w", name, err) } for _, userTemplateName := range g.userTemplateNames { err = g.t.ExecuteTemplate(vBuff, userTemplateName, data) if err != nil { - return vBuff.Bytes(), errors.WithMessage(err, fmt.Sprintf("Failed writing enum data for enum: %q, template: %v", name, userTemplateName)) + return vBuff.Bytes(), fmt.Errorf("failed writing enum data for enum: %q, template: %v: %w", name, userTemplateName, err) } } } + if created < 1 { + // Don't save anything if we didn't actually generate any successful enums. + return nil, nil + } + formatted, err := imports.Process(pkg, vBuff.Bytes(), nil) if err != nil { err = fmt.Errorf("generate: error formatting code %s\n\n%s", err, vBuff.String()) @@ -269,9 +394,8 @@ func (g *Generator) parseFile(fileName string) (*ast.File, error) { // parseEnum looks for the ENUM(x,y,z) formatted documentation from the type definition func (g *Generator) parseEnum(ts *ast.TypeSpec) (*Enum, error) { - if ts.Doc == nil { - return nil, errors.New("No Doc on Enum") + return nil, errors.New("no doc on enum") } enum := &Enum{} @@ -285,10 +409,25 @@ func (g *Generator) parseEnum(ts *ast.TypeSpec) (*Enum, error) { enum.Prefix = g.prefix + enum.Prefix } + commentPreEnumDecl, _, _ := strings.Cut(ts.Doc.Text(), `ENUM(`) + enum.Comment = strings.TrimSpace(commentPreEnumDecl) + enumDecl := getEnumDeclFromComments(ts.Doc.List) + if enumDecl == "" { + return nil, errors.New("failed parsing enum") + } values := strings.Split(strings.TrimSuffix(strings.TrimPrefix(enumDecl, `ENUM(`), `)`), `,`) - data := 0 + var ( + data interface{} + unsigned bool + ) + if strings.HasPrefix(enum.Type, "u") { + data = uint64(0) + unsigned = true + } else { + data = int64(0) + } for _, value := range values { var comment string @@ -303,36 +442,61 @@ func (g *Generator) parseEnum(ts *ast.TypeSpec) (*Enum, error) { // Make sure to leave out any empty parts if value != "" { + rawName := value + valueStr := value + if strings.Contains(value, `=`) { // Get the value specified and set the data to that value. equalIndex := strings.Index(value, `=`) dataVal := strings.TrimSpace(value[equalIndex+1:]) if dataVal != "" { - newData, err := strconv.ParseInt(dataVal, 10, 32) - if err != nil { - return nil, errors.Wrapf(err, "failed parsing the data part of enum value '%s'", value) + valueStr = dataVal + rawName = value[:equalIndex] + if enum.Type == "string" { + if parsed, err := strconv.ParseInt(dataVal, 0, 64); err == nil { + data = parsed + valueStr = rawName + } + if q := identifyQuoted(dataVal); q != "" { + valueStr = trimQuotes(q, dataVal) + } + } else if unsigned { + newData, err := strconv.ParseUint(dataVal, 0, 64) + if err != nil { + err = fmt.Errorf("failed parsing the data part of enum value '%s': %w", value, err) + fmt.Println(err) + return nil, err + } + data = newData + } else { + newData, err := strconv.ParseInt(dataVal, 0, 64) + if err != nil { + err = fmt.Errorf("failed parsing the data part of enum value '%s': %w", value, err) + fmt.Println(err) + return nil, err + } + data = newData } - data = int(newData) - value = value[:equalIndex] } else { - value = strings.TrimSuffix(value, `=`) - fmt.Printf("Ignoring enum with '=' but no value after: %s\n", value) + rawName = strings.TrimSuffix(rawName, `=`) + fmt.Printf("Ignoring enum with '=' but no value after: %s\n", rawName) } } - rawName := strings.TrimSpace(value) - name := strings.Title(rawName) + rawName = strings.TrimSpace(rawName) + valueStr = strings.TrimSpace(valueStr) + name := cases.Title(language.Und, cases.NoLower).String(rawName) prefixedName := name if name != skipHolder { prefixedName = enum.Prefix + name - prefixedName = sanitizeValue(prefixedName) + prefixedName = g.sanitizeValue(prefixedName) if !g.leaveSnakeCase { prefixedName = snakeToCamelCase(prefixedName) } } - ev := EnumValue{Name: name, RawName: rawName, PrefixedName: prefixedName, Value: data, Comment: comment} + ev := EnumValue{Name: name, RawName: rawName, PrefixedName: prefixedName, ValueStr: valueStr, ValueInt: data, Comment: comment} enum.Values = append(enum.Values, ev) - data++ + data = increment(data) } } @@ -341,6 +505,31 @@ func (g *Generator) parseEnum(ts *ast.TypeSpec) (*Enum, error) { return enum, nil } +func identifyQuoted(s string) string { + s = strings.TrimSpace(s) + if strings.HasPrefix(s, `"`) && strings.HasSuffix(s, `"`) { + return `"` + } + if strings.HasPrefix(s, `'`) && strings.HasSuffix(s, `'`) { + return `'` + } + return "" +} + +func trimQuotes(q, s string) string { + return strings.TrimPrefix(strings.TrimSuffix(strings.TrimSpace(s), q), q) +} + +func increment(d interface{}) interface{} { + switch v := d.(type) { + case uint64: + return v + 1 + case int64: + return v + 1 + } + return d +} + func unescapeComment(comment string) string { val, err := url.QueryUnescape(comment) if err != nil { @@ -353,42 +542,41 @@ func unescapeComment(comment string) string { // identifier syntax as described here: https://golang.org/ref/spec#Identifiers // identifier = letter { letter | unicode_digit } // where letter can be unicode_letter or '_' -func sanitizeValue(value string) string { - +func (g *Generator) sanitizeValue(value string) string { // Keep skip value holders if value == skipHolder { return skipHolder } - name := value - - // If the start character is not a unicode letter (this check includes the case of '_') - // then we need to add an exported prefix, so tack on a 'X' at the beginning - if !(unicode.IsLetter(rune(name[0]))) { - name = `X` + name + replacedValue := value + for k, v := range g.replacementNames { + replacedValue = strings.ReplaceAll(replacedValue, k, v) } - // Loop through all the runes and remove any that aren't valid. - for i := 0; i < len(name); i++ { - r := rune(name[i]) - if !(unicode.IsLetter(r) || unicode.IsNumber(r) || r == '_') { - if i < len(name) { - name = name[:i] + name[i+1:] - } else { - // At the end of the string, take off the last char - name = name[:i-1] - } - i-- + nameBuilder := strings.Builder{} + nameBuilder.Grow(len(replacedValue)) + + for i, r := range replacedValue { + // If the start character is not a unicode letter (this check includes the case of '_') + // then we need to add an exported prefix, so tack on a 'X' at the beginning + if i == 0 && !unicode.IsLetter(r) { + nameBuilder.WriteRune('X') + } + + if unicode.IsLetter(r) || unicode.IsNumber(r) || r == '_' { + nameBuilder.WriteRune(r) } } - return name + return nameBuilder.String() } func snakeToCamelCase(value string) string { parts := strings.Split(value, "_") + title := cases.Title(language.Und, cases.NoLower) + for i, part := range parts { - parts[i] = strings.Title(part) + parts[i] = title.String(part) } value = strings.Join(parts, "") @@ -399,52 +587,73 @@ func snakeToCamelCase(value string) string { // that is easier to deal with for the remainder of parsing. It turns multi line declarations and makes a single // string declaration. func getEnumDeclFromComments(comments []*ast.Comment) string { - parts := []string{} - store := false - - lines := []string{} + const EnumPrefix = "ENUM(" + var ( + parts []string + lines []string + store bool + enumParamLevel int + filteredLines []string + ) for _, comment := range comments { lines = append(lines, breakCommentIntoLines(comment)...) } - enumParamLevel := 0 - // Go over all the lines in this comment block - for _, line := range lines { - if store { - paramLevel, trimmed := parseLinePart(line) - if trimmed != "" { - parts = append(parts, trimmed) - } - enumParamLevel += paramLevel - if enumParamLevel == 0 { - // End ENUM Declaration - break - } + filteredLines = make([]string, 0, len(lines)) + for idx := range lines { + line := lines[idx] + // If we're not in the enum, and this line doesn't contain the + // start string, then move along + if !store && !strings.Contains(line, EnumPrefix) { + continue } - if strings.Contains(line, `ENUM(`) { + if !store { + // We must have had the start value in here + store = true enumParamLevel = 1 - startIndex := strings.Index(line, `ENUM(`) - if startIndex >= 0 { - line = line[startIndex+len(`ENUM(`):] - } - paramLevel, trimmed := parseLinePart(line) - if trimmed != "" { - parts = append(parts, trimmed) - } - enumParamLevel += paramLevel - - // Start ENUM Declaration - if enumParamLevel > 0 { - // Store other lines - store = true + start := strings.Index(line, EnumPrefix) + line = line[start+len(EnumPrefix):] + } + lineParamLevel := strings.Count(line, "(") + lineParamLevel = lineParamLevel - strings.Count(line, ")") + + if enumParamLevel+lineParamLevel < 1 { + // We've ended, either with more than we need, or with just enough. Now we need to find the end. + for lineIdx, ch := range line { + if ch == '(' { + enumParamLevel = enumParamLevel + 1 + continue + } + if ch == ')' { + enumParamLevel = enumParamLevel - 1 + if enumParamLevel == 0 { + // We've found the end of the ENUM() definition, + // Cut off the suffix and break out of the loop + line = line[:lineIdx] + store = false + break + } + } } } + + filteredLines = append(filteredLines, line) } if enumParamLevel > 0 { fmt.Println("ENUM Parse error, there is a dangling '(' in your comment.") + return "" } + + // Go over all the lines in this comment block + for _, line := range filteredLines { + _, trimmed := parseLinePart(line) + if trimmed != "" { + parts = append(parts, trimmed) + } + } + joined := fmt.Sprintf("ENUM(%s)", strings.Join(parts, `,`)) return joined } @@ -485,8 +694,11 @@ func breakCommentIntoLines(comment *ast.Comment) []string { } // trimAllTheThings takes off all the cruft of a line that we don't need. +// These lines should be pre-filtered so that we don't have to worry about +// the `ENUM(` prefix and the `)` suffix... those should already be removed. func trimAllTheThings(thing string) string { - return strings.TrimSpace(strings.TrimSuffix(strings.TrimSuffix(strings.TrimSpace(thing), `,`), `)`)) + preTrimmed := strings.TrimSuffix(strings.TrimSpace(thing), `,`) + return strings.TrimSpace(preTrimmed) } // inspect will walk the ast and fill a map of names and their struct information @@ -543,7 +755,6 @@ func copyGenDeclCommentsToSpecs(x *ast.GenDecl) { } } } - } // isTypeSpecEnum checks the comments on the type spec to determine if there is an enum diff --git a/generator/generator_1.18_test.go b/generator/generator_1.18_test.go new file mode 100644 index 00000000..1da1d717 --- /dev/null +++ b/generator/generator_1.18_test.go @@ -0,0 +1,320 @@ +//go:build go1.18 +// +build go1.18 + +package generator + +import ( + "fmt" + "go/parser" + "strings" + "testing" + + "github.com/bradleyjkemp/cupaloy/v2" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +var testExampleFiles = map[string]string{ + "og": `example_test.go`, + "1.18": `example_1.18_test.go`, +} + +// TestNoStructInputFile +func Test118NoStructFile(t *testing.T) { + input := `package test + // Behavior + type SomeInterface interface{ + + } + ` + g := NewGenerator(). + WithoutSnakeToCamel() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestNoFile +func Test118NoFile(t *testing.T) { + g := NewGenerator(). + WithoutSnakeToCamel() + // Parse the file given in arguments + _, err := g.GenerateFromFile("") + assert.NotNil(t, err, "Error generating formatted code") +} + +// TestExampleFile +func Test118ExampleFile(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithSQLDriver(). + WithCaseInsensitiveParse(). + WithNames(). + WithoutSnakeToCamel() + + for name, testExample := range testExampleFiles { + t.Run(name, func(t *testing.T) { + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } + }) + } +} + +// TestExampleFileMoreOptions +func Test118ExampleFileMoreOptions(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithSQLDriver(). + WithCaseInsensitiveParse(). + WithNames(). + WithoutSnakeToCamel(). + WithMustParse(). + WithForceLower(). + WithTemplates(`../example/user_template.tmpl`) + for name, testExample := range testExampleFiles { + t.Run(name, func(t *testing.T) { + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } + }) + } +} + +// TestExampleFile +func Test118NoPrefixExampleFile(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithLowercaseVariant(). + WithNoPrefix(). + WithFlag(). + WithoutSnakeToCamel() + for name, testExample := range testExampleFiles { + t.Run(name, func(t *testing.T) { + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } + }) + } +} + +// TestExampleFile +func Test118NoPrefixExampleFileWithSnakeToCamel(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithLowercaseVariant(). + WithNoPrefix(). + WithFlag() + + for name, testExample := range testExampleFiles { + t.Run(name, func(t *testing.T) { + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } + }) + } +} + +// TestCustomPrefixExampleFile +func Test118CustomPrefixExampleFile(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithLowercaseVariant(). + WithNoPrefix(). + WithFlag(). + WithoutSnakeToCamel(). + WithPtr(). + WithSQLNullInt(). + WithSQLNullStr(). + WithPrefix("Custom_prefix_") + for name, testExample := range testExampleFiles { + t.Run(name, func(t *testing.T) { + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } + }) + } +} + +func Test118AliasParsing(t *testing.T) { + tests := map[string]struct { + input []string + resultingMap map[string]string + err error + }{ + "no aliases": { + resultingMap: map[string]string{}, + }, + "multiple arrays": { + input: []string{ + `!:Bang,a:a`, + `@:AT`, + `&:AND,|:OR`, + }, + resultingMap: map[string]string{ + "a": "a", + "!": "Bang", + "@": "AT", + "&": "AND", + "|": "OR", + }, + }, + "more types": { + input: []string{ + `*:star,+:PLUS`, + `-:less`, + `#:HASH,!:Bang`, + }, + resultingMap: map[string]string{ + "*": "star", + "+": "PLUS", + "-": "less", + "#": "HASH", + "!": "Bang", + }, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + replacementNames, err := ParseAliases(tc.input) + if tc.err != nil { + require.Error(t, err) + require.EqualError(t, err, tc.err.Error()) + } else { + require.NoError(t, err) + require.Equal(t, tc.resultingMap, replacementNames) + } + }) + } +} + +// TestEnumParseFailure +func Test118EnumParseFailure(t *testing.T) { + input := `package test + // Behavior + type SomeInterface interface{ + + } + + // ENUM( + // a, + //} + type Animal int + ` + g := NewGenerator(). + WithoutSnakeToCamel() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Empty(t, string(output)) + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestUintInvalidParsing +func Test118UintInvalidParsing(t *testing.T) { + input := `package test + // ENUM( + // a=-1, + //) + type Animal uint + ` + g := NewGenerator(). + WithoutSnakeToCamel() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Empty(t, string(output)) + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestIntInvalidParsing +func Test118IntInvalidParsing(t *testing.T) { + input := `package test + // ENUM( + // a=c, + //) + type Animal int + ` + g := NewGenerator(). + WithoutSnakeToCamel() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Empty(t, string(output)) + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestAliasing +func Test118Aliasing(t *testing.T) { + input := `package test + // ENUM(a,b,CDEF) with some extra text + type Animal int + ` + aliases, err := ParseAliases([]string{"CDEF:C"}) + require.NoError(t, err) + g := NewGenerator(). + WithoutSnakeToCamel(). + WithAliases(aliases) + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Contains(t, string(output), "// AnimalC is a Animal of type CDEF.") + if false { // Debugging statement + fmt.Println(string(output)) + } +} diff --git a/generator/generator_test.go b/generator/generator_test.go index 0632ee49..9cad7c7c 100644 --- a/generator/generator_test.go +++ b/generator/generator_test.go @@ -1,12 +1,13 @@ package generator import ( + "errors" "fmt" "go/parser" "strings" "testing" - "github.com/bradleyjkemp/cupaloy" + "github.com/bradleyjkemp/cupaloy/v2" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -57,8 +58,52 @@ func TestExampleFile(t *testing.T) { require.Nil(t, err, "Error generating formatted code") outputLines := strings.Split(string(imported), "\n") - err = cupaloy.Snapshot(outputLines) - assert.NoError(t, err, "Output must match snapshot") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } +} + +// TestExampleFileMoreOptions +func TestExampleFileMoreOptions(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithSQLDriver(). + WithCaseInsensitiveParse(). + WithNames(). + WithoutSnakeToCamel(). + WithMustParse(). + WithForceLower(). + WithTemplates(`../example/user_template.tmpl`) + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } +} + +// TestExampleFileMoreOptionsWithForceUpper — test with force upper option +func TestExampleFileMoreOptionsWithForceUpper(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithSQLDriver(). + WithNames(). + WithoutSnakeToCamel(). + WithMustParse(). + WithForceUpper(). + WithTemplates(`../example/user_template.tmpl`) + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) if false { fmt.Println(string(imported)) @@ -78,8 +123,28 @@ func TestNoPrefixExampleFile(t *testing.T) { require.Nil(t, err, "Error generating formatted code") outputLines := strings.Split(string(imported), "\n") - err = cupaloy.Snapshot(outputLines) - assert.NoError(t, err, "Output must match snapshot") + cupaloy.SnapshotT(t, outputLines) + + if false { + fmt.Println(string(imported)) + } +} + +// TestExampleFile +func TestReplacePrefixExampleFile(t *testing.T) { + g := NewGenerator(). + WithMarshal(). + WithLowercaseVariant(). + WithNoPrefix(). + WithPrefix("MyPrefix_"). + WithFlag(). + WithoutSnakeToCamel() + // Parse the file given in arguments + imported, err := g.GenerateFromFile(testExample) + require.Nil(t, err, "Error generating formatted code") + + outputLines := strings.Split(string(imported), "\n") + cupaloy.SnapshotT(t, outputLines) if false { fmt.Println(string(imported)) @@ -99,8 +164,7 @@ func TestNoPrefixExampleFileWithSnakeToCamel(t *testing.T) { require.Nil(t, err, "Error generating formatted code") outputLines := strings.Split(string(imported), "\n") - err = cupaloy.Snapshot(outputLines) - assert.NoError(t, err, "Output must match snapshot") + cupaloy.SnapshotT(t, outputLines) if false { fmt.Println(string(imported)) @@ -124,10 +188,255 @@ func TestCustomPrefixExampleFile(t *testing.T) { require.Nil(t, err, "Error generating formatted code") outputLines := strings.Split(string(imported), "\n") - err = cupaloy.Snapshot(outputLines) - assert.NoError(t, err, "Output must match snapshot") + cupaloy.SnapshotT(t, outputLines) if false { fmt.Println(string(imported)) } } + +func TestAliasParsing(t *testing.T) { + tests := map[string]struct { + input []string + resultingMap map[string]string + err error + }{ + "no aliases": { + resultingMap: map[string]string{}, + }, + "bad input": { + input: []string{"a:b,c"}, + err: errors.New(`invalid formatted alias entry "c", must be in the format "key:value"`), + }, + "multiple arrays": { + input: []string{ + `!:Bang,a:a`, + `@:AT`, + `&:AND,|:OR`, + }, + resultingMap: map[string]string{ + "a": "a", + "!": "Bang", + "@": "AT", + "&": "AND", + "|": "OR", + }, + }, + "more types": { + input: []string{ + `*:star,+:PLUS`, + `-:less`, + `#:HASH,!:Bang`, + }, + resultingMap: map[string]string{ + "*": "star", + "+": "PLUS", + "-": "less", + "#": "HASH", + "!": "Bang", + }, + }, + } + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + replacementNames, err := ParseAliases(tc.input) + if tc.err != nil { + require.Error(t, err) + require.EqualError(t, err, tc.err.Error()) + } else { + require.NoError(t, err) + require.Equal(t, tc.resultingMap, replacementNames) + } + }) + } +} + +// TestEnumParseFailure +func TestEnumParseFailure(t *testing.T) { + input := `package test + // Behavior + type SomeInterface interface{ + + } + + // ENUM( + // a, + //} + type Animal int + ` + g := NewGenerator(). + WithoutSnakeToCamel() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Empty(t, string(output)) + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestUintInvalidParsing +func TestUintInvalidParsing(t *testing.T) { + input := `package test + // ENUM( + // a=-1, + //) + type Animal uint + ` + g := NewGenerator(). + WithoutSnakeToCamel() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Empty(t, string(output)) + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestIntInvalidParsing +func TestIntInvalidParsing(t *testing.T) { + input := `package test + // ENUM( + // a=c, + //) + type Animal int + ` + g := NewGenerator(). + WithoutSnakeToCamel() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Empty(t, string(output)) + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestAliasing +func TestAliasing(t *testing.T) { + input := `package test + // ENUM(a,b,CDEF) with some extra text + type Animal int + ` + aliases, err := ParseAliases([]string{"CDEF:C"}) + require.NoError(t, err) + g := NewGenerator(). + WithoutSnakeToCamel(). + WithAliases(aliases) + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Contains(t, string(output), "// AnimalC is a Animal of type CDEF.") + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestParanthesesParsing +func TestParenthesesParsing(t *testing.T) { + input := `package test + // This is a pre-enum comment that needs (to be handled properly) + // ENUM( + // abc (x), + //). This is an extra string comment (With parentheses of it's own) + // And (another line) with Parentheses + type Animal string + ` + g := NewGenerator() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Contains(t, string(output), "// AnimalAbcX is a Animal of type abc (x).") + assert.NotContains(t, string(output), "// AnimalAnd") + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +// TestQuotedStrings +func TestQuotedStrings(t *testing.T) { + input := `package test + // This is a pre-enum comment that needs (to be handled properly) + // ENUM( + // abc (x), + // ghi = "20", + //). This is an extra string comment (With parentheses of it's own) + // And (another line) with Parentheses + type Animal string + ` + g := NewGenerator() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Contains(t, string(output), "// AnimalAbcX is a Animal of type abc (x).") + assert.Contains(t, string(output), "AnimalGhi Animal = \"20\"") + assert.NotContains(t, string(output), "// AnimalAnd") + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +func TestStringWithSingleDoubleQuoteValue(t *testing.T) { + input := `package test + // ENUM(DoubleQuote='"') + type Char string + ` + g := NewGenerator() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Contains(t, string(output), "CharDoubleQuote Char = \"\\\"\"") + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +func TestStringWithSingleSingleQuoteValue(t *testing.T) { + input := `package test + // ENUM(SingleQuote="'") + type Char string + ` + g := NewGenerator() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Contains(t, string(output), "CharSingleQuote Char = \"'\"") + if false { // Debugging statement + fmt.Println(string(output)) + } +} + +func TestStringWithSingleBacktickValue(t *testing.T) { + input := `package test + // ENUM(SingleQuote="` + "`" + `") + type Char string + ` + g := NewGenerator() + f, err := parser.ParseFile(g.fileSet, "TestRequiredErrors", input, parser.ParseComments) + assert.Nil(t, err, "Error parsing no struct input") + + output, err := g.Generate(f) + assert.Nil(t, err, "Error generating formatted code") + assert.Contains(t, string(output), "CharSingleQuote Char = \"`\"") + if false { // Debugging statement + fmt.Println(string(output)) + } +} diff --git a/generator/template_funcs.go b/generator/template_funcs.go index bd496cbf..8456666f 100644 --- a/generator/template_funcs.go +++ b/generator/template_funcs.go @@ -2,13 +2,22 @@ package generator import ( "fmt" + "strconv" + "strings" ) // Stringify returns a string that is all of the enum value names concatenated without a separator -func Stringify(e Enum) (ret string, err error) { +func Stringify(e Enum, forceLower, forceUpper bool) (ret string, err error) { for _, val := range e.Values { if val.Name != skipHolder { - ret = ret + val.RawName + next := val.RawName + if forceLower { + next = strings.ToLower(next) + } + if forceUpper { + next = strings.ToUpper(next) + } + ret = ret + next } } return @@ -22,7 +31,7 @@ func Mapify(e Enum) (ret string, err error) { for _, val := range e.Values { if val.Name != skipHolder { nextIndex := index + len(val.Name) - ret = fmt.Sprintf("%s%d: %s[%d:%d],\n", ret, val.Value, strName, index, nextIndex) + ret = fmt.Sprintf("%s%s: %s[%d:%d],\n", ret, val.PrefixedName, strName, index, nextIndex) index = nextIndex } } @@ -32,15 +41,18 @@ func Mapify(e Enum) (ret string, err error) { // Unmapify returns a map that is all of the indexes for a string value lookup func Unmapify(e Enum, lowercase bool) (ret string, err error) { + if e.Type == "string" { + return UnmapifyStringEnum(e, lowercase) + } strName := fmt.Sprintf(`_%sName`, e.Name) ret = fmt.Sprintf("map[string]%s{\n", e.Name) index := 0 for _, val := range e.Values { if val.Name != skipHolder { nextIndex := index + len(val.Name) - ret = fmt.Sprintf("%s%s[%d:%d]: %d,\n", ret, strName, index, nextIndex, val.Value) + ret = fmt.Sprintf("%s%s[%d:%d]: %s,\n", ret, strName, index, nextIndex, val.PrefixedName) if lowercase { - ret = fmt.Sprintf("%sstrings.ToLower(%s[%d:%d]): %d,\n", ret, strName, index, nextIndex, val.Value) + ret = fmt.Sprintf("%sstrings.ToLower(%s[%d:%d]): %s,\n", ret, strName, index, nextIndex, val.PrefixedName) } index = nextIndex } @@ -49,8 +61,37 @@ func Unmapify(e Enum, lowercase bool) (ret string, err error) { return } +// Unmapify returns a map that is all of the indexes for a string value lookup +func UnmapifyStringEnum(e Enum, lowercase bool) (ret string, err error) { + var builder strings.Builder + _, err = builder.WriteString("map[string]" + e.Name + "{\n") + if err != nil { + return + } + for _, val := range e.Values { + if val.Name != skipHolder { + _, err = builder.WriteString(fmt.Sprintf("%q:%s,\n", val.ValueStr, val.PrefixedName)) + if err != nil { + return + } + if lowercase && strings.ToLower(val.ValueStr) != val.ValueStr { + _, err = builder.WriteString(fmt.Sprintf("%q:%s,\n", strings.ToLower(val.ValueStr), val.PrefixedName)) + if err != nil { + return + } + } + } + } + builder.WriteByte('}') + ret = builder.String() + return +} + // Namify returns a slice that is all of the possible names for an enum in a slice func Namify(e Enum) (ret string, err error) { + if e.Type == "string" { + return namifyStringEnum(e) + } strName := fmt.Sprintf(`_%sName`, e.Name) ret = "[]string{\n" index := 0 @@ -64,3 +105,25 @@ func Namify(e Enum) (ret string, err error) { ret = ret + "}" return } + +// Namify returns a slice that is all of the possible names for an enum in a slice +func namifyStringEnum(e Enum) (ret string, err error) { + ret = "[]string{\n" + for _, val := range e.Values { + if val.Name != skipHolder { + ret = fmt.Sprintf("%sstring(%s),\n", ret, val.PrefixedName) + } + } + ret = ret + "}" + return +} + +func Offset(index int, enumType string, val EnumValue) (strResult string) { + if strings.HasPrefix(enumType, "u") { + // Unsigned + return strconv.FormatUint(val.ValueInt.(uint64)-uint64(index), 10) + } else { + // Signed + return strconv.FormatInt(val.ValueInt.(int64)-int64(index), 10) + } +} diff --git a/go.mod b/go.mod index acfb87a4..ac233700 100644 --- a/go.mod +++ b/go.mod @@ -1,30 +1,42 @@ module github.com/abice/go-enum -go 1.12 +go 1.20 require ( - github.com/Masterminds/goutils v1.1.0 // indirect - github.com/Masterminds/semver v1.5.0 // indirect - github.com/Masterminds/sprig v2.22.0+incompatible - github.com/bradleyjkemp/cupaloy v2.2.0+incompatible + github.com/Masterminds/sprig/v3 v3.2.3 + github.com/bradleyjkemp/cupaloy/v2 v2.8.0 + github.com/golang/mock v1.6.0 + github.com/labstack/gommon v0.4.2 + github.com/mattn/goveralls v0.0.12 + github.com/spf13/pflag v1.0.5 + github.com/stretchr/testify v1.9.0 + github.com/urfave/cli/v2 v2.27.2 + golang.org/x/text v0.16.0 + golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d + golang.org/x/tools/cmd/cover v0.1.0-deprecated +) + +require ( + github.com/Masterminds/goutils v1.1.1 // indirect + github.com/Masterminds/semver/v3 v3.2.0 // indirect + github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect github.com/davecgh/go-spew v1.1.1 // indirect - github.com/golang/mock v1.4.4 - github.com/google/uuid v1.1.2 // indirect - github.com/huandu/xstrings v1.3.2 // indirect - github.com/imdario/mergo v0.3.11 // indirect - github.com/kevinburke/go-bindata v3.22.0+incompatible - github.com/kr/pretty v0.2.1 // indirect - github.com/labstack/gommon v0.3.0 - github.com/mattn/go-colorable v0.1.8 // indirect - github.com/mattn/goveralls v0.0.7 - github.com/mitchellh/copystructure v1.0.0 // indirect - github.com/mitchellh/reflectwalk v1.0.1 // indirect - github.com/pkg/errors v0.9.1 - github.com/spf13/pflag v1.0.3 - github.com/stretchr/testify v1.4.0 - github.com/urfave/cli/v2 v2.3.0 - golang.org/x/crypto v0.0.0-20201112155050-0c6587e931a9 // indirect - golang.org/x/sys v0.0.0-20201113233024-12cec1faf1ba // indirect - golang.org/x/tools v0.0.0-20201114224030-61ea331ec02b - gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/huandu/xstrings v1.3.3 // indirect + github.com/imdario/mergo v0.3.13 // indirect + github.com/kr/pretty v0.3.1 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mitchellh/copystructure v1.2.0 // indirect + github.com/mitchellh/reflectwalk v1.0.2 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/shopspring/decimal v1.2.0 // indirect + github.com/spf13/cast v1.3.1 // indirect + github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 // indirect + golang.org/x/crypto v0.17.0 // indirect + golang.org/x/mod v0.17.0 // indirect + golang.org/x/sys v0.20.0 // indirect + gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index a88a69f0..3ba5bb16 100644 --- a/go.sum +++ b/go.sum @@ -1,112 +1,147 @@ -github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/Masterminds/goutils v1.1.0 h1:zukEsf/1JZwCMgHiK3GZftabmxiCw4apj3a28RPBiVg= -github.com/Masterminds/goutils v1.1.0/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU= -github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww= -github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= -github.com/Masterminds/sprig v2.22.0+incompatible h1:z4yfnGrZ7netVz+0EDJ0Wi+5VZCSYp4Z0m2dk6cEM60= -github.com/Masterminds/sprig v2.22.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o= -github.com/bradleyjkemp/cupaloy v2.2.0+incompatible h1:Ed7uOEn/o3DIox3PV//SmtXnNO9yPZDdP9wZ0bdcEtI= -github.com/bradleyjkemp/cupaloy v2.2.0+incompatible/go.mod h1:Au1Xw1sgaJ5iSFktEhYsS0dbQiS1B0/XMXl+42y9Ilk= -github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY= -github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI= +github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU= +github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g= +github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ= +github.com/Masterminds/sprig/v3 v3.2.3 h1:eL2fZNezLomi0uOLqjQoN6BfsDD+fyLtgbJMAj9n6YA= +github.com/Masterminds/sprig/v3 v3.2.3/go.mod h1:rXcFaZ2zZbLRJv/xSysmlgIM1u11eBaRMhvYXJNkGuM= +github.com/bradleyjkemp/cupaloy/v2 v2.8.0 h1:any4BmKE+jGIaMpnU8YgH/I2LPiLBufr6oMMlVBbn9M= +github.com/bradleyjkemp/cupaloy/v2 v2.8.0/go.mod h1:bm7JXdkRd4BHJk9HpwqAI8BoAY1lps46Enkdqw6aRX0= +github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= +github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc= -github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= -github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= -github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/huandu/xstrings v1.3.2 h1:L18LIDzqlW6xN2rEkpdV8+oL/IXWJ1APd+vsdYy4Wdw= -github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= -github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/huandu/xstrings v1.3.3 h1:/Gcsuc1x8JVbJ9/rlye4xZnVAbEkGauT8lbebqcQws4= +github.com/huandu/xstrings v1.3.3/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA= -github.com/kevinburke/go-bindata v3.22.0+incompatible h1:/JmqEhIWQ7GRScV0WjX/0tqBrC5D21ALg0H0U/KZ/ts= -github.com/kevinburke/go-bindata v3.22.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi30bslSp9YqD9pysLxunQDdb2CPM= -github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= +github.com/imdario/mergo v0.3.13 h1:lFzP57bqS/wsqKssCGmtLAb8A0wKjLGrve2q3PPVcBk= +github.com/imdario/mergo v0.3.13/go.mod h1:4lJ1jqUDcsbIECGy0RUJAXNIhg+6ocWgb1ALK2O4oXg= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0= -github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k= -github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8= -github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= -github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/goveralls v0.0.7 h1:vzy0i4a2iDzEFMdXIxcanRadkr0FBvSBKUmj0P8SPlQ= -github.com/mattn/goveralls v0.0.7/go.mod h1:h8b4ow6FxSPMQHF6o2ve3qsclnffZjYTNEKmLesRwqw= -github.com/mitchellh/copystructure v1.0.0 h1:Laisrj+bAB6b/yJwB5Bt3ITZhGJdqmxquMKeZ+mmkFQ= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0= +github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/goveralls v0.0.12 h1:PEEeF0k1SsTjOBQ8FOmrOAoCu4ytuMaWCnWe94zxbCg= +github.com/mattn/goveralls v0.0.12/go.mod h1:44ImGEUfmqH8bBtaMrYKsM65LXfNLWmwaxFGjZwgMSQ= github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw= -github.com/mitchellh/reflectwalk v1.0.0 h1:9D+8oIskB4VJBN5SFlmc27fSlIBZaov1Wpk/IfikLNY= +github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw= +github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= -github.com/mitchellh/reflectwalk v1.0.1 h1:FVzMWA5RllMAKIdUSC8mdWo3XtwoecrH79BY70sEEpE= -github.com/mitchellh/reflectwalk v1.0.1/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= +github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q= -github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo= -github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= -github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg= -github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/shopspring/decimal v1.2.0 h1:abSATXmQEYyShuxI4/vyW3tV1MrKAJzCZ/0zLUXYbsQ= +github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= +github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng= +github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/urfave/cli/v2 v2.3.0 h1:qph92Y649prgesehzOrQjdWyxFOp/QVM+6imKHad91M= -github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/urfave/cli/v2 v2.27.2 h1:6e0H+AkS+zDckwPCUrZkKX38mRaau4nL2uipkJpbkcI= +github.com/urfave/cli/v2 v2.27.2/go.mod h1:g0+79LmHHATl7DAcHO99smiR/T7uGLw84w8Y42x+4eM= +github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 h1:+qGGcbkzsfDQNPPe9UDgpxAWQrhbbBXOYJFQDq/dtJw= +github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913/go.mod h1:4aEEwZQutDLsQv2Deui4iYQ6DWTxR14g6m8Wv88+Xqk= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20201112155050-0c6587e931a9 h1:umElSU9WZirRdgu2yFHY0ayQkEnKiOC1TtM3fWXFnoU= -golang.org/x/crypto v0.0.0-20201112155050-0c6587e931a9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.3.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4= +golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= +golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= +golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201113233024-12cec1faf1ba h1:xmhUJGQGbxlod18iJGqVEp9cHIPLl7QiX2aA3to708s= -golang.org/x/sys v0.0.0-20201113233024-12cec1faf1ba/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= +golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20200522201501-cb1345f3a375/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20201114224030-61ea331ec02b h1:Ych5r0Z6MLML1fgf5hTg9p5bV56Xqx9xv9hLgMBATWs= -golang.org/x/tools v0.0.0-20201114224030-61ea331ec02b/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= +golang.org/x/tools/cmd/cover v0.1.0-deprecated h1:Rwy+mWYz6loAF+LnG1jHG/JWMHRMMC2/1XX3Ejkx9lA= +golang.org/x/tools/cmd/cover v0.1.0-deprecated/go.mod h1:hMDiIvlpN1NoVgmjLjUJE9tMHyxHjFX7RuQ+rW12mSA= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/main.go b/main.go index 49102271..725a2701 100644 --- a/main.go +++ b/main.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "io/ioutil" "log" "os" "path/filepath" @@ -13,6 +12,13 @@ import ( "github.com/urfave/cli/v2" ) +var ( + version string + commit string + date string + builtBy string +) + type rootT struct { FileNames cli.StringSlice NoPrefix bool @@ -20,14 +26,24 @@ type rootT struct { NoCase bool Marshal bool SQL bool + SQLInt bool Flag bool + JsonPkg string Prefix string Names bool + Values bool LeaveSnakeCase bool SQLNullStr bool SQLNullInt bool Ptr bool TemplateFileNames cli.StringSlice + Aliases cli.StringSlice + BuildTags cli.StringSlice + MustParse bool + ForceLower bool + ForceUpper bool + NoComments bool + OutputSuffix string } func main() { @@ -42,10 +58,12 @@ func main() { Name: "go-enum", Usage: "An enum generator for go", HideHelpCommand: true, + Version: version, Flags: []cli.Flag{ &cli.StringSliceFlag{ Name: "file", Aliases: []string{"f"}, + EnvVars: []string{"GOFILE"}, Usage: "The file(s) to generate enums. Use more than one flag for more files.", Required: true, Destination: &argv.FileNames, @@ -75,14 +93,24 @@ func main() { Usage: "Adds SQL database scan and value functions.", Destination: &argv.SQL, }, + &cli.BoolFlag{ + Name: "sqlint", + Usage: "Tells the generator that a string typed enum should be stored in sql as an integer value.", + Destination: &argv.SQLInt, + }, &cli.BoolFlag{ Name: "flag", Usage: "Adds golang flag functions.", Destination: &argv.Flag, }, + &cli.StringFlag{ + Name: "jsonpkg", + Usage: "Custom json package for imports instead encoding/json.", + Destination: &argv.JsonPkg, + }, &cli.StringFlag{ Name: "prefix", - Usage: "Replaces the prefix with a user one.", + Usage: "Adds a prefix with a user one. If you would like to replace the prefix, then combine this option with --noprefix.", Destination: &argv.Prefix, }, &cli.BoolFlag{ @@ -90,6 +118,11 @@ func main() { Usage: "Generates a 'Names() []string' function, and adds the possible enum values in the error response during parsing", Destination: &argv.Names, }, + &cli.BoolFlag{ + Name: "values", + Usage: "Generates a 'Values() []{{ENUM}}' function.", + Destination: &argv.Values, + }, &cli.BoolFlag{ Name: "nocamel", Usage: "Removes the snake_case to CamelCase name changing", @@ -116,11 +149,59 @@ func main() { Usage: "Additional template file(s) to generate enums. Use more than one flag for more files. Templates will be executed in alphabetical order.", Destination: &argv.TemplateFileNames, }, + &cli.StringSliceFlag{ + Name: "alias", + Aliases: []string{"a"}, + Usage: "Adds or replaces aliases for a non alphanumeric value that needs to be accounted for. [Format should be \"key:value,key2:value2\", or specify multiple entries, or both!]", + Destination: &argv.Aliases, + }, + &cli.BoolFlag{ + Name: "mustparse", + Usage: "Adds a Must version of the Parse that will panic on failure.", + Destination: &argv.MustParse, + }, + &cli.BoolFlag{ + Name: "forcelower", + Usage: "Forces a camel cased comment to generate lowercased names.", + Destination: &argv.ForceLower, + }, + &cli.BoolFlag{ + Name: "forceupper", + Usage: "Forces a camel cased comment to generate uppercased names.", + Destination: &argv.ForceUpper, + }, + &cli.BoolFlag{ + Name: "nocomments", + Usage: "Removes auto generated comments. If you add your own comments, these will still be created.", + Destination: &argv.NoComments, + }, + &cli.StringSliceFlag{ + Name: "buildtag", + Aliases: []string{"b"}, + Usage: "Adds build tags to a generated enum file.", + Destination: &argv.BuildTags, + }, + &cli.StringFlag{ + Name: "output-suffix", + Usage: "Changes the default filename suffix of _enum to something else. `.go` will be appended to the end of the string no matter what, so that `_test.go` cases can be accommodated ", + Destination: &argv.OutputSuffix, + }, }, Action: func(ctx *cli.Context) error { + aliases, err := generator.ParseAliases(argv.Aliases.Value()) + if err != nil { + return err + } for _, fileOption := range argv.FileNames.Value() { g := generator.NewGenerator() + g.Version = version + g.Revision = commit + g.BuildDate = date + g.BuiltBy = builtBy + + g.WithBuildTags(argv.BuildTags.Value()...) + g.WithAliases(aliases) if argv.NoPrefix { g.WithNoPrefix() @@ -137,15 +218,24 @@ func main() { if argv.SQL { g.WithSQLDriver() } + if argv.SQLInt { + g.WithSQLInt() + } if argv.Flag { g.WithFlag() } if argv.Names { g.WithNames() } + if argv.Values { + g.WithValues() + } if argv.LeaveSnakeCase { g.WithoutSnakeToCamel() } + if argv.JsonPkg != "" { + g.WithJsonPkg(argv.JsonPkg) + } if argv.Prefix != "" { g.WithPrefix(argv.Prefix) } @@ -158,6 +248,18 @@ func main() { if argv.SQLNullStr { g.WithSQLNullStr() } + if argv.MustParse { + g.WithMustParse() + } + if argv.ForceLower { + g.WithForceLower() + } + if argv.ForceUpper { + g.WithForceUpper() + } + if argv.NoComments { + g.WithNoComments() + } if templates := []string(argv.TemplateFileNames.Value()); len(templates) > 0 { for _, t := range templates { if fn, err := globFilenames(t); err != nil { @@ -175,12 +277,21 @@ func main() { filenames = fn } + outputSuffix := `_enum` + if argv.OutputSuffix != "" { + outputSuffix = argv.OutputSuffix + } + for _, fileName := range filenames { originalName := fileName out("go-enum started. file: %s\n", color.Cyan(originalName)) fileName, _ = filepath.Abs(fileName) - outFilePath := fmt.Sprintf("%s_enum.go", strings.TrimSuffix(fileName, filepath.Ext(fileName))) + + outFilePath := fmt.Sprintf("%s%s.go", strings.TrimSuffix(fileName, filepath.Ext(fileName)), outputSuffix) + if strings.HasSuffix(fileName, "_test.go") { + outFilePath = strings.Replace(outFilePath, "_test"+outputSuffix+".go", outputSuffix+"_test.go", 1) + } // Parse the file given in arguments raw, err := g.GenerateFromFile(fileName) @@ -194,8 +305,8 @@ func main() { continue } - mode := int(0644) - err = ioutil.WriteFile(outFilePath, raw, os.FileMode(mode)) + mode := int(0o644) + err = os.WriteFile(outFilePath, raw, os.FileMode(mode)) if err != nil { return fmt.Errorf("failed writing to file %s: %s", color.Cyan(outFilePath), color.Red(err)) } diff --git a/tools.go b/tools.go index 612666e4..ab6b3c69 100644 --- a/tools.go +++ b/tools.go @@ -1,3 +1,4 @@ +//go:build tools // +build tools package main @@ -5,7 +6,6 @@ package main import ( _ "github.com/golang/mock/mockgen" _ "github.com/golang/mock/mockgen/model" - _ "github.com/kevinburke/go-bindata/go-bindata" _ "github.com/mattn/goveralls" _ "golang.org/x/tools/cmd/cover" _ "golang.org/x/tools/cmd/goimports"