lib/types/data.go

package types

import (
	"errors"
)

var (
	ErrExistKey = errors.New("not exist.")
	ErrFormat   = errors.New("error format.")
)

type Data map[string]interface{}

func (data Data) Get(key string) (interface{}, error) {
	value, exist := data[key]
	if !exist {
		return "", ErrExistKey
	}

	return value, nil
}

func (data Data) GetString(key string) (string, error) {
	value, err := data.Get(key)
	if err != nil {
		return "", err
	}

	switch value.(type) {
	case string:
		return value.(string), nil
	}

	return "", ErrFormat
}

func (data Data) GetSlice(key string) (res []interface{}, err error) {
	value, err := data.Get(key)
	if err != nil {
		return nil, err
	}

	switch value.(type) {
	case []interface{}:
		return value.([]interface{}), nil
	default:
		return nil, ErrFormat
	}
}

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.(type) {
		case string:
			res = append(res, v.(string))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

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.(type) {
		case float64:
			res = append(res, int(v.(float64)))
		default:
			return nil, ErrFormat
		}
	}

	return res, nil
}

func (data Data) GetInt64(key string) (int64, error) {
	value, err := data.Get(key)
	if err != nil {
		return 0, err
	}

	switch value.(type) {
	case int:
		return int64(value.(int)), nil

	case int64:
		return value.(int64), nil

	case float64:
		return int64(value.(float64)), nil
	}

	return 0, ErrFormat
}

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
}

func (data Data) GetInt(key string) (int, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int(value), nil
}

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
}

func (data Data) GetInt16(key string) (int16, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int16(value), nil
}

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
}

func (data Data) GetInt8(key string) (int8, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return int8(value), nil
}

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
}

func (data Data) GetBool(key string) (bool, error) {
	value, err := data.Get(key)
	if err != nil {
		return false, err
	}

	switch value.(type) {
	case bool:
		return value.(bool), nil
	}

	return false, ErrFormat
}

func (data Data) GetTimestamp(key string) (Timestamp, error) {
	value, err := data.GetInt64(key)
	if err != nil {
		return 0, err
	}

	return Timestamp(value), nil
}