468 lines
10 KiB
Go
468 lines
10 KiB
Go
// Code generated by go-enum DO NOT EDIT.
|
|
// Version: -
|
|
// Revision: -
|
|
// Build Date: -
|
|
// Built By: -
|
|
|
|
package fields
|
|
|
|
import (
|
|
"database/sql/driver"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
// PostStatusDraft is a PostStatus of type Draft.
|
|
PostStatusDraft PostStatus = iota
|
|
// PostStatusPublished is a PostStatus of type Published.
|
|
PostStatusPublished
|
|
)
|
|
|
|
var ErrInvalidPostStatus = fmt.Errorf("not a valid PostStatus, try [%s]", strings.Join(_PostStatusNames, ", "))
|
|
|
|
const _PostStatusName = "draftpublished"
|
|
|
|
var _PostStatusNames = []string{
|
|
_PostStatusName[0:5],
|
|
_PostStatusName[5:14],
|
|
}
|
|
|
|
// PostStatusNames returns a list of possible string values of PostStatus.
|
|
func PostStatusNames() []string {
|
|
tmp := make([]string, len(_PostStatusNames))
|
|
copy(tmp, _PostStatusNames)
|
|
return tmp
|
|
}
|
|
|
|
// PostStatusValues returns a list of the values for PostStatus
|
|
func PostStatusValues() []PostStatus {
|
|
return []PostStatus{
|
|
PostStatusDraft,
|
|
PostStatusPublished,
|
|
}
|
|
}
|
|
|
|
var _PostStatusMap = map[PostStatus]string{
|
|
PostStatusDraft: _PostStatusName[0:5],
|
|
PostStatusPublished: _PostStatusName[5:14],
|
|
}
|
|
|
|
// String implements the Stringer interface.
|
|
func (x PostStatus) String() string {
|
|
if str, ok := _PostStatusMap[x]; ok {
|
|
return str
|
|
}
|
|
return fmt.Sprintf("PostStatus(%d)", x)
|
|
}
|
|
|
|
// IsValid provides a quick way to determine if the typed value is
|
|
// part of the allowed enumerated values
|
|
func (x PostStatus) IsValid() bool {
|
|
_, ok := _PostStatusMap[x]
|
|
return ok
|
|
}
|
|
|
|
var _PostStatusValue = map[string]PostStatus{
|
|
_PostStatusName[0:5]: PostStatusDraft,
|
|
_PostStatusName[5:14]: PostStatusPublished,
|
|
}
|
|
|
|
// ParsePostStatus attempts to convert a string to a PostStatus.
|
|
func ParsePostStatus(name string) (PostStatus, error) {
|
|
if x, ok := _PostStatusValue[name]; ok {
|
|
return x, nil
|
|
}
|
|
return PostStatus(0), fmt.Errorf("%s is %w", name, ErrInvalidPostStatus)
|
|
}
|
|
|
|
var errPostStatusNilPtr = errors.New("value pointer is nil") // one per type for package clashes
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *PostStatus) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
*x = PostStatus(0)
|
|
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 = PostStatus(v)
|
|
case string:
|
|
*x, err = ParsePostStatus(v)
|
|
if err != nil {
|
|
// try parsing the integer value as a string
|
|
if val, verr := strconv.Atoi(v); verr == nil {
|
|
*x, err = PostStatus(val), nil
|
|
}
|
|
}
|
|
case []byte:
|
|
*x, err = ParsePostStatus(string(v))
|
|
if err != nil {
|
|
// try parsing the integer value as a string
|
|
if val, verr := strconv.Atoi(string(v)); verr == nil {
|
|
*x, err = PostStatus(val), nil
|
|
}
|
|
}
|
|
case PostStatus:
|
|
*x = v
|
|
case int:
|
|
*x = PostStatus(v)
|
|
case *PostStatus:
|
|
if v == nil {
|
|
return errPostStatusNilPtr
|
|
}
|
|
*x = *v
|
|
case uint:
|
|
*x = PostStatus(v)
|
|
case uint64:
|
|
*x = PostStatus(v)
|
|
case *int:
|
|
if v == nil {
|
|
return errPostStatusNilPtr
|
|
}
|
|
*x = PostStatus(*v)
|
|
case *int64:
|
|
if v == nil {
|
|
return errPostStatusNilPtr
|
|
}
|
|
*x = PostStatus(*v)
|
|
case float64: // json marshals everything as a float64 if it's a number
|
|
*x = PostStatus(v)
|
|
case *float64: // json marshals everything as a float64 if it's a number
|
|
if v == nil {
|
|
return errPostStatusNilPtr
|
|
}
|
|
*x = PostStatus(*v)
|
|
case *uint:
|
|
if v == nil {
|
|
return errPostStatusNilPtr
|
|
}
|
|
*x = PostStatus(*v)
|
|
case *uint64:
|
|
if v == nil {
|
|
return errPostStatusNilPtr
|
|
}
|
|
*x = PostStatus(*v)
|
|
case *string:
|
|
if v == nil {
|
|
return errPostStatusNilPtr
|
|
}
|
|
*x, err = ParsePostStatus(*v)
|
|
if err != nil {
|
|
// try parsing the integer value as a string
|
|
if val, verr := strconv.Atoi(*v); verr == nil {
|
|
*x, err = PostStatus(val), nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x PostStatus) Value() (driver.Value, error) {
|
|
return int64(x), nil
|
|
}
|
|
|
|
// Set implements the Golang flag.Value interface func.
|
|
func (x *PostStatus) Set(val string) error {
|
|
v, err := ParsePostStatus(val)
|
|
*x = v
|
|
return err
|
|
}
|
|
|
|
// Get implements the Golang flag.Getter interface func.
|
|
func (x *PostStatus) Get() interface{} {
|
|
return *x
|
|
}
|
|
|
|
// Type implements the github.com/spf13/pFlag Value interface.
|
|
func (x *PostStatus) Type() string {
|
|
return "PostStatus"
|
|
}
|
|
|
|
type NullPostStatus struct {
|
|
PostStatus PostStatus
|
|
Valid bool
|
|
}
|
|
|
|
func NewNullPostStatus(val interface{}) (x NullPostStatus) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *NullPostStatus) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
x.PostStatus, x.Valid = PostStatus(0), false
|
|
return
|
|
}
|
|
|
|
err = x.PostStatus.Scan(value)
|
|
x.Valid = (err == nil)
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullPostStatus) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
// driver.Value accepts int64 for int values.
|
|
return int64(x.PostStatus), nil
|
|
}
|
|
|
|
type NullPostStatusStr struct {
|
|
NullPostStatus
|
|
}
|
|
|
|
func NewNullPostStatusStr(val interface{}) (x NullPostStatusStr) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullPostStatusStr) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
return x.PostStatus.String(), nil
|
|
}
|
|
|
|
const (
|
|
// PostTypeArticle is a PostType of type Article.
|
|
PostTypeArticle PostType = iota
|
|
// PostTypePicture is a PostType of type Picture.
|
|
PostTypePicture
|
|
// PostTypeVideo is a PostType of type Video.
|
|
PostTypeVideo
|
|
// PostTypeAudio is a PostType of type Audio.
|
|
PostTypeAudio
|
|
)
|
|
|
|
var ErrInvalidPostType = fmt.Errorf("not a valid PostType, try [%s]", strings.Join(_PostTypeNames, ", "))
|
|
|
|
const _PostTypeName = "ArticlePictureVideoAudio"
|
|
|
|
var _PostTypeNames = []string{
|
|
_PostTypeName[0:7],
|
|
_PostTypeName[7:14],
|
|
_PostTypeName[14:19],
|
|
_PostTypeName[19:24],
|
|
}
|
|
|
|
// PostTypeNames returns a list of possible string values of PostType.
|
|
func PostTypeNames() []string {
|
|
tmp := make([]string, len(_PostTypeNames))
|
|
copy(tmp, _PostTypeNames)
|
|
return tmp
|
|
}
|
|
|
|
// PostTypeValues returns a list of the values for PostType
|
|
func PostTypeValues() []PostType {
|
|
return []PostType{
|
|
PostTypeArticle,
|
|
PostTypePicture,
|
|
PostTypeVideo,
|
|
PostTypeAudio,
|
|
}
|
|
}
|
|
|
|
var _PostTypeMap = map[PostType]string{
|
|
PostTypeArticle: _PostTypeName[0:7],
|
|
PostTypePicture: _PostTypeName[7:14],
|
|
PostTypeVideo: _PostTypeName[14:19],
|
|
PostTypeAudio: _PostTypeName[19:24],
|
|
}
|
|
|
|
// String implements the Stringer interface.
|
|
func (x PostType) String() string {
|
|
if str, ok := _PostTypeMap[x]; ok {
|
|
return str
|
|
}
|
|
return fmt.Sprintf("PostType(%d)", x)
|
|
}
|
|
|
|
// IsValid provides a quick way to determine if the typed value is
|
|
// part of the allowed enumerated values
|
|
func (x PostType) IsValid() bool {
|
|
_, ok := _PostTypeMap[x]
|
|
return ok
|
|
}
|
|
|
|
var _PostTypeValue = map[string]PostType{
|
|
_PostTypeName[0:7]: PostTypeArticle,
|
|
_PostTypeName[7:14]: PostTypePicture,
|
|
_PostTypeName[14:19]: PostTypeVideo,
|
|
_PostTypeName[19:24]: PostTypeAudio,
|
|
}
|
|
|
|
// ParsePostType attempts to convert a string to a PostType.
|
|
func ParsePostType(name string) (PostType, error) {
|
|
if x, ok := _PostTypeValue[name]; ok {
|
|
return x, nil
|
|
}
|
|
return PostType(0), fmt.Errorf("%s is %w", name, ErrInvalidPostType)
|
|
}
|
|
|
|
var errPostTypeNilPtr = errors.New("value pointer is nil") // one per type for package clashes
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *PostType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
*x = PostType(0)
|
|
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 = PostType(v)
|
|
case string:
|
|
*x, err = ParsePostType(v)
|
|
if err != nil {
|
|
// try parsing the integer value as a string
|
|
if val, verr := strconv.Atoi(v); verr == nil {
|
|
*x, err = PostType(val), nil
|
|
}
|
|
}
|
|
case []byte:
|
|
*x, err = ParsePostType(string(v))
|
|
if err != nil {
|
|
// try parsing the integer value as a string
|
|
if val, verr := strconv.Atoi(string(v)); verr == nil {
|
|
*x, err = PostType(val), nil
|
|
}
|
|
}
|
|
case PostType:
|
|
*x = v
|
|
case int:
|
|
*x = PostType(v)
|
|
case *PostType:
|
|
if v == nil {
|
|
return errPostTypeNilPtr
|
|
}
|
|
*x = *v
|
|
case uint:
|
|
*x = PostType(v)
|
|
case uint64:
|
|
*x = PostType(v)
|
|
case *int:
|
|
if v == nil {
|
|
return errPostTypeNilPtr
|
|
}
|
|
*x = PostType(*v)
|
|
case *int64:
|
|
if v == nil {
|
|
return errPostTypeNilPtr
|
|
}
|
|
*x = PostType(*v)
|
|
case float64: // json marshals everything as a float64 if it's a number
|
|
*x = PostType(v)
|
|
case *float64: // json marshals everything as a float64 if it's a number
|
|
if v == nil {
|
|
return errPostTypeNilPtr
|
|
}
|
|
*x = PostType(*v)
|
|
case *uint:
|
|
if v == nil {
|
|
return errPostTypeNilPtr
|
|
}
|
|
*x = PostType(*v)
|
|
case *uint64:
|
|
if v == nil {
|
|
return errPostTypeNilPtr
|
|
}
|
|
*x = PostType(*v)
|
|
case *string:
|
|
if v == nil {
|
|
return errPostTypeNilPtr
|
|
}
|
|
*x, err = ParsePostType(*v)
|
|
if err != nil {
|
|
// try parsing the integer value as a string
|
|
if val, verr := strconv.Atoi(*v); verr == nil {
|
|
*x, err = PostType(val), nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x PostType) Value() (driver.Value, error) {
|
|
return int64(x), nil
|
|
}
|
|
|
|
// Set implements the Golang flag.Value interface func.
|
|
func (x *PostType) Set(val string) error {
|
|
v, err := ParsePostType(val)
|
|
*x = v
|
|
return err
|
|
}
|
|
|
|
// Get implements the Golang flag.Getter interface func.
|
|
func (x *PostType) Get() interface{} {
|
|
return *x
|
|
}
|
|
|
|
// Type implements the github.com/spf13/pFlag Value interface.
|
|
func (x *PostType) Type() string {
|
|
return "PostType"
|
|
}
|
|
|
|
type NullPostType struct {
|
|
PostType PostType
|
|
Valid bool
|
|
}
|
|
|
|
func NewNullPostType(val interface{}) (x NullPostType) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *NullPostType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
x.PostType, x.Valid = PostType(0), false
|
|
return
|
|
}
|
|
|
|
err = x.PostType.Scan(value)
|
|
x.Valid = (err == nil)
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullPostType) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
// driver.Value accepts int64 for int values.
|
|
return int64(x.PostType), nil
|
|
}
|
|
|
|
type NullPostTypeStr struct {
|
|
NullPostType
|
|
}
|
|
|
|
func NewNullPostTypeStr(val interface{}) (x NullPostTypeStr) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullPostTypeStr) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
return x.PostType.String(), nil
|
|
}
|