mirror of
https://github.com/astaxie/beego.git
synced 2024-12-23 07:20:49 +00:00
244 lines
4.8 KiB
Go
244 lines
4.8 KiB
Go
package orm
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type StrTo string
|
|
|
|
func (f *StrTo) Set(v string) {
|
|
if v != "" {
|
|
*f = StrTo(v)
|
|
} else {
|
|
f.Clear()
|
|
}
|
|
}
|
|
|
|
func (f *StrTo) Clear() {
|
|
*f = StrTo(0x1E)
|
|
}
|
|
|
|
func (f StrTo) Exist() bool {
|
|
return string(f) != string(0x1E)
|
|
}
|
|
|
|
func (f StrTo) Bool() (bool, error) {
|
|
return strconv.ParseBool(f.String())
|
|
}
|
|
|
|
func (f StrTo) Float32() (float32, error) {
|
|
v, err := strconv.ParseFloat(f.String(), 32)
|
|
return float32(v), err
|
|
}
|
|
|
|
func (f StrTo) Float64() (float64, error) {
|
|
return strconv.ParseFloat(f.String(), 64)
|
|
}
|
|
|
|
func (f StrTo) Int() (int, error) {
|
|
v, err := strconv.ParseInt(f.String(), 10, 32)
|
|
return int(v), err
|
|
}
|
|
|
|
func (f StrTo) Int8() (int8, error) {
|
|
v, err := strconv.ParseInt(f.String(), 10, 8)
|
|
return int8(v), err
|
|
}
|
|
|
|
func (f StrTo) Int16() (int16, error) {
|
|
v, err := strconv.ParseInt(f.String(), 10, 16)
|
|
return int16(v), err
|
|
}
|
|
|
|
func (f StrTo) Int32() (int32, error) {
|
|
v, err := strconv.ParseInt(f.String(), 10, 32)
|
|
return int32(v), err
|
|
}
|
|
|
|
func (f StrTo) Int64() (int64, error) {
|
|
v, err := strconv.ParseInt(f.String(), 10, 64)
|
|
return int64(v), err
|
|
}
|
|
|
|
func (f StrTo) Uint() (uint, error) {
|
|
v, err := strconv.ParseUint(f.String(), 10, 32)
|
|
return uint(v), err
|
|
}
|
|
|
|
func (f StrTo) Uint8() (uint8, error) {
|
|
v, err := strconv.ParseUint(f.String(), 10, 8)
|
|
return uint8(v), err
|
|
}
|
|
|
|
func (f StrTo) Uint16() (uint16, error) {
|
|
v, err := strconv.ParseUint(f.String(), 10, 16)
|
|
return uint16(v), err
|
|
}
|
|
|
|
func (f StrTo) Uint32() (uint32, error) {
|
|
v, err := strconv.ParseUint(f.String(), 10, 32)
|
|
return uint32(v), err
|
|
}
|
|
|
|
func (f StrTo) Uint64() (uint64, error) {
|
|
v, err := strconv.ParseUint(f.String(), 10, 64)
|
|
return uint64(v), err
|
|
}
|
|
|
|
func (f StrTo) String() string {
|
|
if f.Exist() {
|
|
return string(f)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func ToStr(value interface{}, args ...int) (s string) {
|
|
switch v := value.(type) {
|
|
case bool:
|
|
s = strconv.FormatBool(v)
|
|
case float32:
|
|
s = strconv.FormatFloat(float64(v), 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 32))
|
|
case float64:
|
|
s = strconv.FormatFloat(v, 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 64))
|
|
case int:
|
|
s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
|
|
case int8:
|
|
s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
|
|
case int16:
|
|
s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
|
|
case int32:
|
|
s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
|
|
case int64:
|
|
s = strconv.FormatInt(v, argInt(args).Get(0, 10))
|
|
case uint:
|
|
s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
|
|
case uint8:
|
|
s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
|
|
case uint16:
|
|
s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
|
|
case uint32:
|
|
s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
|
|
case uint64:
|
|
s = strconv.FormatUint(v, argInt(args).Get(0, 10))
|
|
case string:
|
|
s = v
|
|
case []byte:
|
|
s = string(v)
|
|
default:
|
|
s = fmt.Sprintf("%v", v)
|
|
}
|
|
return s
|
|
}
|
|
|
|
func ToInt64(value interface{}) (d int64) {
|
|
val := reflect.ValueOf(value)
|
|
switch value.(type) {
|
|
case int, int8, int16, int32, int64:
|
|
d = val.Int()
|
|
case uint, uint8, uint16, uint32, uint64:
|
|
d = int64(val.Uint())
|
|
default:
|
|
panic(fmt.Errorf("ToInt64 need numeric not `%T`", value))
|
|
}
|
|
return
|
|
}
|
|
|
|
func snakeString(s string) string {
|
|
data := make([]byte, 0, len(s)*2)
|
|
j := false
|
|
num := len(s)
|
|
for i := 0; i < num; i++ {
|
|
d := s[i]
|
|
if i > 0 && d >= 'A' && d <= 'Z' && j {
|
|
data = append(data, '_')
|
|
}
|
|
if d != '_' {
|
|
j = true
|
|
}
|
|
data = append(data, d)
|
|
}
|
|
return strings.ToLower(string(data[:len(data)]))
|
|
}
|
|
|
|
func camelString(s string) string {
|
|
data := make([]byte, 0, len(s))
|
|
j := false
|
|
k := false
|
|
num := len(s) - 1
|
|
for i := 0; i <= num; i++ {
|
|
d := s[i]
|
|
if k == false && d >= 'A' && d <= 'Z' {
|
|
k = true
|
|
}
|
|
if d >= 'a' && d <= 'z' && (j || k == false) {
|
|
d = d - 32
|
|
j = false
|
|
k = true
|
|
}
|
|
if k && d == '_' && num > i && s[i+1] >= 'a' && s[i+1] <= 'z' {
|
|
j = true
|
|
continue
|
|
}
|
|
data = append(data, d)
|
|
}
|
|
return string(data[:len(data)])
|
|
}
|
|
|
|
type argString []string
|
|
|
|
func (a argString) Get(i int, args ...string) (r string) {
|
|
if i >= 0 && i < len(a) {
|
|
r = a[i]
|
|
} else if len(args) > 0 {
|
|
r = args[0]
|
|
}
|
|
return
|
|
}
|
|
|
|
type argInt []int
|
|
|
|
func (a argInt) Get(i int, args ...int) (r int) {
|
|
if i >= 0 && i < len(a) {
|
|
r = a[i]
|
|
}
|
|
if len(args) > 0 {
|
|
r = args[0]
|
|
}
|
|
return
|
|
}
|
|
|
|
type argAny []interface{}
|
|
|
|
func (a argAny) Get(i int, args ...interface{}) (r interface{}) {
|
|
if i >= 0 && i < len(a) {
|
|
r = a[i]
|
|
}
|
|
if len(args) > 0 {
|
|
r = args[0]
|
|
}
|
|
return
|
|
}
|
|
|
|
func timeParse(dateString, format string) (time.Time, error) {
|
|
tp, err := time.ParseInLocation(format, dateString, DefaultTimeLoc)
|
|
return tp, err
|
|
}
|
|
|
|
func timeFormat(t time.Time, format string) string {
|
|
return t.Format(format)
|
|
}
|
|
|
|
func indirectType(v reflect.Type) reflect.Type {
|
|
switch v.Kind() {
|
|
case reflect.Ptr:
|
|
return indirectType(v.Elem())
|
|
default:
|
|
return v
|
|
}
|
|
return v
|
|
}
|