You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
503 lines
9.3 KiB
Go
503 lines
9.3 KiB
Go
package types
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
)
|
|
|
|
// 錯誤訊息
|
|
var (
|
|
ErrExistKey = errors.New("not exist")
|
|
ErrFormat = errors.New("error format")
|
|
)
|
|
|
|
// Data 資料
|
|
type Data map[string]interface{}
|
|
|
|
// Get 取得資料
|
|
func (data Data) Get(key string) (interface{}, error) {
|
|
value, exist := data[key]
|
|
if !exist {
|
|
return "", ErrExistKey
|
|
}
|
|
|
|
return value, nil
|
|
}
|
|
|
|
// GetString 取得字串
|
|
func (data Data) GetString(key string) (string, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case []byte:
|
|
return string(value), nil
|
|
case string:
|
|
return value, nil
|
|
default:
|
|
return "", ErrFormat
|
|
}
|
|
}
|
|
|
|
// MustGetString 強制取得字串
|
|
func (data Data) MustGetString(key string) string {
|
|
value, _ := data.GetString(key)
|
|
return value
|
|
}
|
|
|
|
// GetBytes 取得字串
|
|
func (data Data) GetBytes(key string) ([]byte, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case []byte:
|
|
return value, nil
|
|
case string:
|
|
return []byte(value), nil
|
|
default:
|
|
return nil, ErrFormat
|
|
}
|
|
}
|
|
|
|
// MustGetBytes 強制取得字串
|
|
func (data Data) MustGetBytes(key string) []byte {
|
|
value, _ := data.GetBytes(key)
|
|
return value
|
|
}
|
|
|
|
// GetSlice 取得切片
|
|
func (data Data) GetSlice(key string) (res Slice, err error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case []interface{}:
|
|
return Slice(value), nil
|
|
case Slice:
|
|
return value, nil
|
|
default:
|
|
return nil, ErrFormat
|
|
}
|
|
}
|
|
|
|
// MustGetSlice 強制取得切片
|
|
func (data Data) MustGetSlice(key string) Slice {
|
|
values, _ := data.GetSlice(key)
|
|
return values
|
|
}
|
|
|
|
// GetStringSlice 取得字串切片
|
|
func (data Data) GetStringSlice(key string) (res []string, err error) {
|
|
values, err := data.GetSlice(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, v := range values {
|
|
switch v := v.(type) {
|
|
case string:
|
|
res = append(res, v)
|
|
default:
|
|
return nil, ErrFormat
|
|
}
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// MustGetStringSlice 強制取得字串切片
|
|
func (data Data) MustGetStringSlice(key string) []string {
|
|
values, _ := data.GetStringSlice(key)
|
|
return values
|
|
}
|
|
|
|
// GetIntSlice 取得整數切片
|
|
func (data Data) GetIntSlice(key string) (res []int, err error) {
|
|
values, err := data.GetSlice(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, v := range values {
|
|
switch v := v.(type) {
|
|
case int:
|
|
res = append(res, int(v))
|
|
case uint:
|
|
res = append(res, int(v))
|
|
case int8:
|
|
res = append(res, int(v))
|
|
case uint8:
|
|
res = append(res, int(v))
|
|
case int16:
|
|
res = append(res, int(v))
|
|
case uint16:
|
|
res = append(res, int(v))
|
|
case int32:
|
|
res = append(res, int(v))
|
|
case uint32:
|
|
res = append(res, int(v))
|
|
case int64:
|
|
res = append(res, int(v))
|
|
case uint64:
|
|
res = append(res, int(v))
|
|
case float32:
|
|
res = append(res, int(v))
|
|
case float64:
|
|
res = append(res, int(v))
|
|
default:
|
|
return nil, ErrFormat
|
|
}
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// MustGetIntSlice 強制取得整數切片
|
|
func (data Data) MustGetIntSlice(key string) []int {
|
|
values, _ := data.GetIntSlice(key)
|
|
return values
|
|
}
|
|
|
|
// GetData 取得資料
|
|
func (data Data) GetData(key string) (Data, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case map[string]interface{}:
|
|
return Data(value), nil
|
|
case Data:
|
|
return value, nil
|
|
default:
|
|
return nil, ErrFormat
|
|
}
|
|
}
|
|
|
|
// MustGetData 強制取得資料
|
|
func (data Data) MustGetData(key string) Data {
|
|
value, _ := data.GetData(key)
|
|
return value
|
|
}
|
|
|
|
// GetDataSlice 取得資料切片
|
|
func (data Data) GetDataSlice(key string) ([]Data, error) {
|
|
values, err := data.GetSlice(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var vals []Data
|
|
for _, v := range values {
|
|
switch v := v.(type) {
|
|
case map[string]interface{}:
|
|
vals = append(vals, Data(v))
|
|
default:
|
|
return nil, ErrFormat
|
|
}
|
|
}
|
|
|
|
return vals, nil
|
|
}
|
|
|
|
// MustGetDataSlice 強制取得資料切片
|
|
func (data Data) MustGetDataSlice(key string) []Data {
|
|
values, _ := data.GetDataSlice(key)
|
|
return values
|
|
}
|
|
|
|
// GetFloat64 取得64位元浮點數
|
|
func (data Data) GetFloat64(key string) (float64, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case float32:
|
|
return float64(value), nil
|
|
case float64:
|
|
return value, nil
|
|
default:
|
|
return 0, ErrFormat
|
|
}
|
|
}
|
|
|
|
// MustGetFloat64 強制取得64位元浮點數
|
|
func (data Data) MustGetFloat64(key string) float64 {
|
|
value, _ := data.GetFloat64(key)
|
|
return value
|
|
}
|
|
|
|
// GetInt64 取得64位元整數
|
|
func (data Data) GetInt64(key string) (int64, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case int:
|
|
return int64(value), nil
|
|
case uint:
|
|
return int64(value), nil
|
|
case int8:
|
|
return int64(value), nil
|
|
case uint8:
|
|
return int64(value), nil
|
|
case int16:
|
|
return int64(value), nil
|
|
case uint16:
|
|
return int64(value), nil
|
|
case int32:
|
|
return int64(value), nil
|
|
case uint32:
|
|
return int64(value), nil
|
|
case int64:
|
|
return value, nil
|
|
case float64:
|
|
return int64(value), nil
|
|
default:
|
|
return 0, ErrFormat
|
|
}
|
|
}
|
|
|
|
// MustGetInt64 強制取得64位元整數
|
|
func (data Data) MustGetInt64(key string) int64 {
|
|
value, _ := data.GetInt64(key)
|
|
return value
|
|
}
|
|
|
|
// GetUint64 取得64位元正整數
|
|
func (data Data) GetUint64(key string) (uint64, error) {
|
|
value, err := data.GetInt64(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if value < 0 {
|
|
return 0, ErrFormat
|
|
}
|
|
|
|
return uint64(value), nil
|
|
}
|
|
|
|
// MustGetUint64 強制取得64位元正整數
|
|
func (data Data) MustGetUint64(key string) uint64 {
|
|
value, _ := data.GetUint64(key)
|
|
return value
|
|
}
|
|
|
|
// GetInt 取得整數
|
|
func (data Data) GetInt(key string) (int, error) {
|
|
value, err := data.GetInt64(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return int(value), nil
|
|
}
|
|
|
|
// MustGetInt 強制取得整數
|
|
func (data Data) MustGetInt(key string) int {
|
|
value, _ := data.GetInt(key)
|
|
return value
|
|
}
|
|
|
|
// GetUint 取得正整數
|
|
func (data Data) GetUint(key string) (uint, error) {
|
|
value, err := data.GetInt64(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if value < 0 {
|
|
return 0, ErrFormat
|
|
}
|
|
|
|
return uint(value), nil
|
|
}
|
|
|
|
// MustGetUint 強制取得正整數
|
|
func (data Data) MustGetUint(key string) uint {
|
|
value, _ := data.GetUint(key)
|
|
return value
|
|
}
|
|
|
|
// GetInt16 取得16位元整數
|
|
func (data Data) GetInt16(key string) (int16, error) {
|
|
value, err := data.GetInt64(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return int16(value), nil
|
|
}
|
|
|
|
// MustGetInt16 強制取得16位元整數
|
|
func (data Data) MustGetInt16(key string) uint16 {
|
|
value, _ := data.GetUint16(key)
|
|
return value
|
|
}
|
|
|
|
// GetUint16 取得16位元正整數
|
|
func (data Data) GetUint16(key string) (uint16, error) {
|
|
value, err := data.GetInt64(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if value < 0 {
|
|
return 0, ErrFormat
|
|
}
|
|
|
|
return uint16(value), nil
|
|
}
|
|
|
|
// MustGetUint16 強制取得16位元正整數
|
|
func (data Data) MustGetUint16(key string) uint16 {
|
|
value, _ := data.GetUint16(key)
|
|
return value
|
|
}
|
|
|
|
// GetInt8 取得8位元整數
|
|
func (data Data) GetInt8(key string) (int8, error) {
|
|
value, err := data.GetInt64(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return int8(value), nil
|
|
}
|
|
|
|
// MustGetInt8 強制取得8位元整數
|
|
func (data Data) MustGetInt8(key string) int8 {
|
|
value, _ := data.GetInt8(key)
|
|
return value
|
|
}
|
|
|
|
// GetUint8 取得8位元正整數
|
|
func (data Data) GetUint8(key string) (uint8, error) {
|
|
value, err := data.GetInt64(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if value < 0 {
|
|
return 0, ErrFormat
|
|
}
|
|
|
|
return uint8(value), nil
|
|
}
|
|
|
|
// MustGetUint8 強制取得8位元正整數
|
|
func (data Data) MustGetUint8(key string) uint8 {
|
|
value, _ := data.GetUint8(key)
|
|
return value
|
|
}
|
|
|
|
// GetBool 取得布林值
|
|
func (data Data) GetBool(key string) (bool, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case uint8:
|
|
return value > 0, nil
|
|
case int64:
|
|
return value > 0, nil
|
|
case float64:
|
|
return value > 0, nil
|
|
case bool:
|
|
return value, nil
|
|
}
|
|
|
|
return false, ErrFormat
|
|
}
|
|
|
|
// MustGetBool 強制取得布林值
|
|
func (data Data) MustGetBool(key string) bool {
|
|
value, _ := data.GetBool(key)
|
|
return value
|
|
}
|
|
|
|
// GetTimestamp 取得時間戳記
|
|
func (data Data) GetTimestamp(key string) (Timestamp, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case int:
|
|
return Timestamp(value), nil
|
|
case uint:
|
|
return Timestamp(value), nil
|
|
case int64:
|
|
return Timestamp(value), nil
|
|
case uint64:
|
|
return Timestamp(value), nil
|
|
case float64:
|
|
return Timestamp(value), nil
|
|
|
|
case Timestamp:
|
|
return value, nil
|
|
}
|
|
|
|
return 0, ErrFormat
|
|
}
|
|
|
|
// MustGetTimestamp 強制取得時間戳記
|
|
func (data Data) MustGetTimestamp(key string) Timestamp {
|
|
value, _ := data.GetTimestamp(key)
|
|
return value
|
|
}
|
|
|
|
// JSON 取得json
|
|
func (data Data) JSON() ([]byte, error) {
|
|
bs, err := json.Marshal(&data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return bs, nil
|
|
}
|
|
|
|
// MustJSON 強制取得json
|
|
func (data Data) MustJSON() []byte {
|
|
bs, _ := data.JSON()
|
|
return bs
|
|
}
|
|
|
|
// Get 取得資料
|
|
func (data Data) GetPage(key string) (*Page, error) {
|
|
value, err := data.Get(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch value := value.(type) {
|
|
case Page:
|
|
return &value, nil
|
|
}
|
|
|
|
return nil, ErrFormat
|
|
}
|
|
|
|
// Get 取得資料
|
|
func (data Data) MustGetPage(key string) *Page {
|
|
value, _ := data.GetPage(key)
|
|
|
|
return value
|
|
}
|