825 lines
22 KiB
Go
825 lines
22 KiB
Go
// Code generated by go-enum DO NOT EDIT.
|
|
// Version: -
|
|
// Revision: -
|
|
// Build Date: -
|
|
// Built By: -
|
|
|
|
package consts
|
|
|
|
import (
|
|
"database/sql/driver"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
// GenderMale is a Gender of type male.
|
|
GenderMale Gender = "male"
|
|
// GenderFemale is a Gender of type female.
|
|
GenderFemale Gender = "female"
|
|
// GenderSecret is a Gender of type secret.
|
|
GenderSecret Gender = "secret"
|
|
)
|
|
|
|
var ErrInvalidGender = fmt.Errorf("not a valid Gender, try [%s]", strings.Join(_GenderNames, ", "))
|
|
|
|
var _GenderNames = []string{
|
|
string(GenderMale),
|
|
string(GenderFemale),
|
|
string(GenderSecret),
|
|
}
|
|
|
|
// GenderNames returns a list of possible string values of Gender.
|
|
func GenderNames() []string {
|
|
tmp := make([]string, len(_GenderNames))
|
|
copy(tmp, _GenderNames)
|
|
return tmp
|
|
}
|
|
|
|
// GenderValues returns a list of the values for Gender
|
|
func GenderValues() []Gender {
|
|
return []Gender{
|
|
GenderMale,
|
|
GenderFemale,
|
|
GenderSecret,
|
|
}
|
|
}
|
|
|
|
// String implements the Stringer interface.
|
|
func (x Gender) 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 Gender) IsValid() bool {
|
|
_, err := ParseGender(string(x))
|
|
return err == nil
|
|
}
|
|
|
|
var _GenderValue = map[string]Gender{
|
|
"male": GenderMale,
|
|
"female": GenderFemale,
|
|
"secret": GenderSecret,
|
|
}
|
|
|
|
// ParseGender attempts to convert a string to a Gender.
|
|
func ParseGender(name string) (Gender, error) {
|
|
if x, ok := _GenderValue[name]; ok {
|
|
return x, nil
|
|
}
|
|
return Gender(""), fmt.Errorf("%s is %w", name, ErrInvalidGender)
|
|
}
|
|
|
|
var errGenderNilPtr = errors.New("value pointer is nil") // one per type for package clashes
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *Gender) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
*x = Gender("")
|
|
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 = ParseGender(v)
|
|
case []byte:
|
|
*x, err = ParseGender(string(v))
|
|
case Gender:
|
|
*x = v
|
|
case *Gender:
|
|
if v == nil {
|
|
return errGenderNilPtr
|
|
}
|
|
*x = *v
|
|
case *string:
|
|
if v == nil {
|
|
return errGenderNilPtr
|
|
}
|
|
*x, err = ParseGender(*v)
|
|
default:
|
|
return errors.New("invalid type for Gender")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x Gender) Value() (driver.Value, error) {
|
|
return x.String(), nil
|
|
}
|
|
|
|
// Set implements the Golang flag.Value interface func.
|
|
func (x *Gender) Set(val string) error {
|
|
v, err := ParseGender(val)
|
|
*x = v
|
|
return err
|
|
}
|
|
|
|
// Get implements the Golang flag.Getter interface func.
|
|
func (x *Gender) Get() interface{} {
|
|
return *x
|
|
}
|
|
|
|
// Type implements the github.com/spf13/pFlag Value interface.
|
|
func (x *Gender) Type() string {
|
|
return "Gender"
|
|
}
|
|
|
|
type NullGender struct {
|
|
Gender Gender
|
|
Valid bool
|
|
}
|
|
|
|
func NewNullGender(val interface{}) (x NullGender) {
|
|
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 *NullGender) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
x.Gender, x.Valid = Gender(""), false
|
|
return
|
|
}
|
|
|
|
err = x.Gender.Scan(value)
|
|
x.Valid = (err == nil)
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullGender) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
// driver.Value accepts int64 for int values.
|
|
return string(x.Gender), nil
|
|
}
|
|
|
|
type NullGenderStr struct {
|
|
NullGender
|
|
}
|
|
|
|
func NewNullGenderStr(val interface{}) (x NullGenderStr) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullGenderStr) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
return x.Gender.String(), nil
|
|
}
|
|
|
|
const (
|
|
// NotificationTypeSystem is a NotificationType of type system.
|
|
NotificationTypeSystem NotificationType = "system"
|
|
// NotificationTypeOrder is a NotificationType of type order.
|
|
NotificationTypeOrder NotificationType = "order"
|
|
// NotificationTypeAudit is a NotificationType of type audit.
|
|
NotificationTypeAudit NotificationType = "audit"
|
|
// NotificationTypeInteraction is a NotificationType of type interaction.
|
|
NotificationTypeInteraction NotificationType = "interaction"
|
|
)
|
|
|
|
var ErrInvalidNotificationType = fmt.Errorf("not a valid NotificationType, try [%s]", strings.Join(_NotificationTypeNames, ", "))
|
|
|
|
var _NotificationTypeNames = []string{
|
|
string(NotificationTypeSystem),
|
|
string(NotificationTypeOrder),
|
|
string(NotificationTypeAudit),
|
|
string(NotificationTypeInteraction),
|
|
}
|
|
|
|
// NotificationTypeNames returns a list of possible string values of NotificationType.
|
|
func NotificationTypeNames() []string {
|
|
tmp := make([]string, len(_NotificationTypeNames))
|
|
copy(tmp, _NotificationTypeNames)
|
|
return tmp
|
|
}
|
|
|
|
// NotificationTypeValues returns a list of the values for NotificationType
|
|
func NotificationTypeValues() []NotificationType {
|
|
return []NotificationType{
|
|
NotificationTypeSystem,
|
|
NotificationTypeOrder,
|
|
NotificationTypeAudit,
|
|
NotificationTypeInteraction,
|
|
}
|
|
}
|
|
|
|
// String implements the Stringer interface.
|
|
func (x NotificationType) 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 NotificationType) IsValid() bool {
|
|
_, err := ParseNotificationType(string(x))
|
|
return err == nil
|
|
}
|
|
|
|
var _NotificationTypeValue = map[string]NotificationType{
|
|
"system": NotificationTypeSystem,
|
|
"order": NotificationTypeOrder,
|
|
"audit": NotificationTypeAudit,
|
|
"interaction": NotificationTypeInteraction,
|
|
}
|
|
|
|
// ParseNotificationType attempts to convert a string to a NotificationType.
|
|
func ParseNotificationType(name string) (NotificationType, error) {
|
|
if x, ok := _NotificationTypeValue[name]; ok {
|
|
return x, nil
|
|
}
|
|
return NotificationType(""), fmt.Errorf("%s is %w", name, ErrInvalidNotificationType)
|
|
}
|
|
|
|
var errNotificationTypeNilPtr = errors.New("value pointer is nil") // one per type for package clashes
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *NotificationType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
*x = NotificationType("")
|
|
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 = ParseNotificationType(v)
|
|
case []byte:
|
|
*x, err = ParseNotificationType(string(v))
|
|
case NotificationType:
|
|
*x = v
|
|
case *NotificationType:
|
|
if v == nil {
|
|
return errNotificationTypeNilPtr
|
|
}
|
|
*x = *v
|
|
case *string:
|
|
if v == nil {
|
|
return errNotificationTypeNilPtr
|
|
}
|
|
*x, err = ParseNotificationType(*v)
|
|
default:
|
|
return errors.New("invalid type for NotificationType")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NotificationType) Value() (driver.Value, error) {
|
|
return x.String(), nil
|
|
}
|
|
|
|
// Set implements the Golang flag.Value interface func.
|
|
func (x *NotificationType) Set(val string) error {
|
|
v, err := ParseNotificationType(val)
|
|
*x = v
|
|
return err
|
|
}
|
|
|
|
// Get implements the Golang flag.Getter interface func.
|
|
func (x *NotificationType) Get() interface{} {
|
|
return *x
|
|
}
|
|
|
|
// Type implements the github.com/spf13/pFlag Value interface.
|
|
func (x *NotificationType) Type() string {
|
|
return "NotificationType"
|
|
}
|
|
|
|
type NullNotificationType struct {
|
|
NotificationType NotificationType
|
|
Valid bool
|
|
}
|
|
|
|
func NewNullNotificationType(val interface{}) (x NullNotificationType) {
|
|
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 *NullNotificationType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
x.NotificationType, x.Valid = NotificationType(""), false
|
|
return
|
|
}
|
|
|
|
err = x.NotificationType.Scan(value)
|
|
x.Valid = (err == nil)
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullNotificationType) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
// driver.Value accepts int64 for int values.
|
|
return string(x.NotificationType), nil
|
|
}
|
|
|
|
type NullNotificationTypeStr struct {
|
|
NullNotificationType
|
|
}
|
|
|
|
func NewNullNotificationTypeStr(val interface{}) (x NullNotificationTypeStr) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullNotificationTypeStr) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
return x.NotificationType.String(), nil
|
|
}
|
|
|
|
const (
|
|
// PayoutAccountTypeBank is a PayoutAccountType of type bank.
|
|
PayoutAccountTypeBank PayoutAccountType = "bank"
|
|
// PayoutAccountTypeAlipay is a PayoutAccountType of type alipay.
|
|
PayoutAccountTypeAlipay PayoutAccountType = "alipay"
|
|
)
|
|
|
|
var ErrInvalidPayoutAccountType = fmt.Errorf("not a valid PayoutAccountType, try [%s]", strings.Join(_PayoutAccountTypeNames, ", "))
|
|
|
|
var _PayoutAccountTypeNames = []string{
|
|
string(PayoutAccountTypeBank),
|
|
string(PayoutAccountTypeAlipay),
|
|
}
|
|
|
|
// PayoutAccountTypeNames returns a list of possible string values of PayoutAccountType.
|
|
func PayoutAccountTypeNames() []string {
|
|
tmp := make([]string, len(_PayoutAccountTypeNames))
|
|
copy(tmp, _PayoutAccountTypeNames)
|
|
return tmp
|
|
}
|
|
|
|
// PayoutAccountTypeValues returns a list of the values for PayoutAccountType
|
|
func PayoutAccountTypeValues() []PayoutAccountType {
|
|
return []PayoutAccountType{
|
|
PayoutAccountTypeBank,
|
|
PayoutAccountTypeAlipay,
|
|
}
|
|
}
|
|
|
|
// String implements the Stringer interface.
|
|
func (x PayoutAccountType) 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 PayoutAccountType) IsValid() bool {
|
|
_, err := ParsePayoutAccountType(string(x))
|
|
return err == nil
|
|
}
|
|
|
|
var _PayoutAccountTypeValue = map[string]PayoutAccountType{
|
|
"bank": PayoutAccountTypeBank,
|
|
"alipay": PayoutAccountTypeAlipay,
|
|
}
|
|
|
|
// ParsePayoutAccountType attempts to convert a string to a PayoutAccountType.
|
|
func ParsePayoutAccountType(name string) (PayoutAccountType, error) {
|
|
if x, ok := _PayoutAccountTypeValue[name]; ok {
|
|
return x, nil
|
|
}
|
|
return PayoutAccountType(""), fmt.Errorf("%s is %w", name, ErrInvalidPayoutAccountType)
|
|
}
|
|
|
|
var errPayoutAccountTypeNilPtr = errors.New("value pointer is nil") // one per type for package clashes
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *PayoutAccountType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
*x = PayoutAccountType("")
|
|
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 = ParsePayoutAccountType(v)
|
|
case []byte:
|
|
*x, err = ParsePayoutAccountType(string(v))
|
|
case PayoutAccountType:
|
|
*x = v
|
|
case *PayoutAccountType:
|
|
if v == nil {
|
|
return errPayoutAccountTypeNilPtr
|
|
}
|
|
*x = *v
|
|
case *string:
|
|
if v == nil {
|
|
return errPayoutAccountTypeNilPtr
|
|
}
|
|
*x, err = ParsePayoutAccountType(*v)
|
|
default:
|
|
return errors.New("invalid type for PayoutAccountType")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x PayoutAccountType) Value() (driver.Value, error) {
|
|
return x.String(), nil
|
|
}
|
|
|
|
// Set implements the Golang flag.Value interface func.
|
|
func (x *PayoutAccountType) Set(val string) error {
|
|
v, err := ParsePayoutAccountType(val)
|
|
*x = v
|
|
return err
|
|
}
|
|
|
|
// Get implements the Golang flag.Getter interface func.
|
|
func (x *PayoutAccountType) Get() interface{} {
|
|
return *x
|
|
}
|
|
|
|
// Type implements the github.com/spf13/pFlag Value interface.
|
|
func (x *PayoutAccountType) Type() string {
|
|
return "PayoutAccountType"
|
|
}
|
|
|
|
type NullPayoutAccountType struct {
|
|
PayoutAccountType PayoutAccountType
|
|
Valid bool
|
|
}
|
|
|
|
func NewNullPayoutAccountType(val interface{}) (x NullPayoutAccountType) {
|
|
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 *NullPayoutAccountType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
x.PayoutAccountType, x.Valid = PayoutAccountType(""), false
|
|
return
|
|
}
|
|
|
|
err = x.PayoutAccountType.Scan(value)
|
|
x.Valid = (err == nil)
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullPayoutAccountType) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
// driver.Value accepts int64 for int values.
|
|
return string(x.PayoutAccountType), nil
|
|
}
|
|
|
|
type NullPayoutAccountTypeStr struct {
|
|
NullPayoutAccountType
|
|
}
|
|
|
|
func NewNullPayoutAccountTypeStr(val interface{}) (x NullPayoutAccountTypeStr) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullPayoutAccountTypeStr) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
return x.PayoutAccountType.String(), nil
|
|
}
|
|
|
|
const (
|
|
// UserCommentActionTypeLike is a UserCommentActionType of type like.
|
|
UserCommentActionTypeLike UserCommentActionType = "like"
|
|
)
|
|
|
|
var ErrInvalidUserCommentActionType = fmt.Errorf("not a valid UserCommentActionType, try [%s]", strings.Join(_UserCommentActionTypeNames, ", "))
|
|
|
|
var _UserCommentActionTypeNames = []string{
|
|
string(UserCommentActionTypeLike),
|
|
}
|
|
|
|
// UserCommentActionTypeNames returns a list of possible string values of UserCommentActionType.
|
|
func UserCommentActionTypeNames() []string {
|
|
tmp := make([]string, len(_UserCommentActionTypeNames))
|
|
copy(tmp, _UserCommentActionTypeNames)
|
|
return tmp
|
|
}
|
|
|
|
// UserCommentActionTypeValues returns a list of the values for UserCommentActionType
|
|
func UserCommentActionTypeValues() []UserCommentActionType {
|
|
return []UserCommentActionType{
|
|
UserCommentActionTypeLike,
|
|
}
|
|
}
|
|
|
|
// String implements the Stringer interface.
|
|
func (x UserCommentActionType) 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 UserCommentActionType) IsValid() bool {
|
|
_, err := ParseUserCommentActionType(string(x))
|
|
return err == nil
|
|
}
|
|
|
|
var _UserCommentActionTypeValue = map[string]UserCommentActionType{
|
|
"like": UserCommentActionTypeLike,
|
|
}
|
|
|
|
// ParseUserCommentActionType attempts to convert a string to a UserCommentActionType.
|
|
func ParseUserCommentActionType(name string) (UserCommentActionType, error) {
|
|
if x, ok := _UserCommentActionTypeValue[name]; ok {
|
|
return x, nil
|
|
}
|
|
return UserCommentActionType(""), fmt.Errorf("%s is %w", name, ErrInvalidUserCommentActionType)
|
|
}
|
|
|
|
var errUserCommentActionTypeNilPtr = errors.New("value pointer is nil") // one per type for package clashes
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *UserCommentActionType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
*x = UserCommentActionType("")
|
|
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 = ParseUserCommentActionType(v)
|
|
case []byte:
|
|
*x, err = ParseUserCommentActionType(string(v))
|
|
case UserCommentActionType:
|
|
*x = v
|
|
case *UserCommentActionType:
|
|
if v == nil {
|
|
return errUserCommentActionTypeNilPtr
|
|
}
|
|
*x = *v
|
|
case *string:
|
|
if v == nil {
|
|
return errUserCommentActionTypeNilPtr
|
|
}
|
|
*x, err = ParseUserCommentActionType(*v)
|
|
default:
|
|
return errors.New("invalid type for UserCommentActionType")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x UserCommentActionType) Value() (driver.Value, error) {
|
|
return x.String(), nil
|
|
}
|
|
|
|
// Set implements the Golang flag.Value interface func.
|
|
func (x *UserCommentActionType) Set(val string) error {
|
|
v, err := ParseUserCommentActionType(val)
|
|
*x = v
|
|
return err
|
|
}
|
|
|
|
// Get implements the Golang flag.Getter interface func.
|
|
func (x *UserCommentActionType) Get() interface{} {
|
|
return *x
|
|
}
|
|
|
|
// Type implements the github.com/spf13/pFlag Value interface.
|
|
func (x *UserCommentActionType) Type() string {
|
|
return "UserCommentActionType"
|
|
}
|
|
|
|
type NullUserCommentActionType struct {
|
|
UserCommentActionType UserCommentActionType
|
|
Valid bool
|
|
}
|
|
|
|
func NewNullUserCommentActionType(val interface{}) (x NullUserCommentActionType) {
|
|
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 *NullUserCommentActionType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
x.UserCommentActionType, x.Valid = UserCommentActionType(""), false
|
|
return
|
|
}
|
|
|
|
err = x.UserCommentActionType.Scan(value)
|
|
x.Valid = (err == nil)
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullUserCommentActionType) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
// driver.Value accepts int64 for int values.
|
|
return string(x.UserCommentActionType), nil
|
|
}
|
|
|
|
type NullUserCommentActionTypeStr struct {
|
|
NullUserCommentActionType
|
|
}
|
|
|
|
func NewNullUserCommentActionTypeStr(val interface{}) (x NullUserCommentActionTypeStr) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullUserCommentActionTypeStr) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
return x.UserCommentActionType.String(), nil
|
|
}
|
|
|
|
const (
|
|
// UserContentActionTypeLike is a UserContentActionType of type like.
|
|
UserContentActionTypeLike UserContentActionType = "like"
|
|
// UserContentActionTypeFavorite is a UserContentActionType of type favorite.
|
|
UserContentActionTypeFavorite UserContentActionType = "favorite"
|
|
)
|
|
|
|
var ErrInvalidUserContentActionType = fmt.Errorf("not a valid UserContentActionType, try [%s]", strings.Join(_UserContentActionTypeNames, ", "))
|
|
|
|
var _UserContentActionTypeNames = []string{
|
|
string(UserContentActionTypeLike),
|
|
string(UserContentActionTypeFavorite),
|
|
}
|
|
|
|
// UserContentActionTypeNames returns a list of possible string values of UserContentActionType.
|
|
func UserContentActionTypeNames() []string {
|
|
tmp := make([]string, len(_UserContentActionTypeNames))
|
|
copy(tmp, _UserContentActionTypeNames)
|
|
return tmp
|
|
}
|
|
|
|
// UserContentActionTypeValues returns a list of the values for UserContentActionType
|
|
func UserContentActionTypeValues() []UserContentActionType {
|
|
return []UserContentActionType{
|
|
UserContentActionTypeLike,
|
|
UserContentActionTypeFavorite,
|
|
}
|
|
}
|
|
|
|
// String implements the Stringer interface.
|
|
func (x UserContentActionType) 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 UserContentActionType) IsValid() bool {
|
|
_, err := ParseUserContentActionType(string(x))
|
|
return err == nil
|
|
}
|
|
|
|
var _UserContentActionTypeValue = map[string]UserContentActionType{
|
|
"like": UserContentActionTypeLike,
|
|
"favorite": UserContentActionTypeFavorite,
|
|
}
|
|
|
|
// ParseUserContentActionType attempts to convert a string to a UserContentActionType.
|
|
func ParseUserContentActionType(name string) (UserContentActionType, error) {
|
|
if x, ok := _UserContentActionTypeValue[name]; ok {
|
|
return x, nil
|
|
}
|
|
return UserContentActionType(""), fmt.Errorf("%s is %w", name, ErrInvalidUserContentActionType)
|
|
}
|
|
|
|
var errUserContentActionTypeNilPtr = errors.New("value pointer is nil") // one per type for package clashes
|
|
|
|
// Scan implements the Scanner interface.
|
|
func (x *UserContentActionType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
*x = UserContentActionType("")
|
|
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 = ParseUserContentActionType(v)
|
|
case []byte:
|
|
*x, err = ParseUserContentActionType(string(v))
|
|
case UserContentActionType:
|
|
*x = v
|
|
case *UserContentActionType:
|
|
if v == nil {
|
|
return errUserContentActionTypeNilPtr
|
|
}
|
|
*x = *v
|
|
case *string:
|
|
if v == nil {
|
|
return errUserContentActionTypeNilPtr
|
|
}
|
|
*x, err = ParseUserContentActionType(*v)
|
|
default:
|
|
return errors.New("invalid type for UserContentActionType")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x UserContentActionType) Value() (driver.Value, error) {
|
|
return x.String(), nil
|
|
}
|
|
|
|
// Set implements the Golang flag.Value interface func.
|
|
func (x *UserContentActionType) Set(val string) error {
|
|
v, err := ParseUserContentActionType(val)
|
|
*x = v
|
|
return err
|
|
}
|
|
|
|
// Get implements the Golang flag.Getter interface func.
|
|
func (x *UserContentActionType) Get() interface{} {
|
|
return *x
|
|
}
|
|
|
|
// Type implements the github.com/spf13/pFlag Value interface.
|
|
func (x *UserContentActionType) Type() string {
|
|
return "UserContentActionType"
|
|
}
|
|
|
|
type NullUserContentActionType struct {
|
|
UserContentActionType UserContentActionType
|
|
Valid bool
|
|
}
|
|
|
|
func NewNullUserContentActionType(val interface{}) (x NullUserContentActionType) {
|
|
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 *NullUserContentActionType) Scan(value interface{}) (err error) {
|
|
if value == nil {
|
|
x.UserContentActionType, x.Valid = UserContentActionType(""), false
|
|
return
|
|
}
|
|
|
|
err = x.UserContentActionType.Scan(value)
|
|
x.Valid = (err == nil)
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullUserContentActionType) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
// driver.Value accepts int64 for int values.
|
|
return string(x.UserContentActionType), nil
|
|
}
|
|
|
|
type NullUserContentActionTypeStr struct {
|
|
NullUserContentActionType
|
|
}
|
|
|
|
func NewNullUserContentActionTypeStr(val interface{}) (x NullUserContentActionTypeStr) {
|
|
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
|
|
return
|
|
}
|
|
|
|
// Value implements the driver Valuer interface.
|
|
func (x NullUserContentActionTypeStr) Value() (driver.Value, error) {
|
|
if !x.Valid {
|
|
return nil, nil
|
|
}
|
|
return x.UserContentActionType.String(), nil
|
|
}
|