initial commit
This commit is contained in:
@@ -0,0 +1,558 @@
|
||||
package record
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// Record stores mixed scalar data (Boolean, numeric, and string) and provides type-safe methods to retrieve it.
|
||||
// It automatically casts values where possible.
|
||||
//
|
||||
// https://go.dev/ref/spec#Types
|
||||
type Record map[string]any
|
||||
|
||||
func (r Record) Bool(column string) bool {
|
||||
value, _ := r.BoolSafe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) BoolSafe(column string) (bool, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
return r[column].(bool), true
|
||||
case "int":
|
||||
return r[column].(int) > 0, true
|
||||
case "int16":
|
||||
return r[column].(int16) > 0, true
|
||||
case "int32":
|
||||
return r[column].(int32) > 0, true
|
||||
case "int64":
|
||||
return r[column].(int64) > 0, true
|
||||
case "string":
|
||||
if value, err := strconv.ParseBool(r[column].(string)); err == nil {
|
||||
return value, true
|
||||
}
|
||||
case "uint":
|
||||
return r[column].(uint) > 0, true
|
||||
case "uint8":
|
||||
return r[column].(uint8) > 0, true
|
||||
case "uint16":
|
||||
return r[column].(uint16) > 0, true
|
||||
case "uint32":
|
||||
return r[column].(uint32) > 0, true
|
||||
case "uint64":
|
||||
return r[column].(uint64) > 0, true
|
||||
}
|
||||
}
|
||||
|
||||
return false, false
|
||||
}
|
||||
|
||||
func (r Record) Byte(column string) byte {
|
||||
value, _ := r.ByteSafe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) ByteSafe(column string) (byte, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "byte":
|
||||
return r[column].(byte), true
|
||||
case "uint8":
|
||||
return byte(r[column].(uint8)), true
|
||||
}
|
||||
}
|
||||
|
||||
return byte(0), false
|
||||
}
|
||||
|
||||
func (r Record) Float32(column string) float32 {
|
||||
value, _ := r.Float32Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Float32Safe(column string) (float32, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "float32":
|
||||
return r[column].(float32), true
|
||||
case "float64":
|
||||
return float32(r[column].(float64)), true
|
||||
case "int":
|
||||
return float32(r[column].(int)), true
|
||||
case "int16":
|
||||
return float32(r[column].(int16)), true
|
||||
case "int32":
|
||||
return float32(r[column].(int32)), true
|
||||
case "int64":
|
||||
return float32(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseFloat(r[column].(string), 32); err == nil {
|
||||
return float32(value), true
|
||||
}
|
||||
case "uint":
|
||||
return float32(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return float32(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return float32(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return float32(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return float32(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Float64(column string) float64 {
|
||||
value, _ := r.Float64Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Float64Safe(column string) (float64, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "float32":
|
||||
return float64(r[column].(float32)), true
|
||||
case "float64":
|
||||
return r[column].(float64), true
|
||||
case "int":
|
||||
return float64(r[column].(int)), true
|
||||
case "int16":
|
||||
return float64(r[column].(int16)), true
|
||||
case "int32":
|
||||
return float64(r[column].(int32)), true
|
||||
case "int64":
|
||||
return float64(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseFloat(r[column].(string), 64); err == nil {
|
||||
return float64(value), true
|
||||
}
|
||||
case "uint":
|
||||
return float64(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return float64(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return float64(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return float64(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return float64(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Has(column string) bool {
|
||||
_, ok := r.TypeOf(column)
|
||||
return ok
|
||||
}
|
||||
|
||||
func (r Record) Int(column string) int {
|
||||
value, _ := r.IntSafe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) IntSafe(column string) (int, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return r[column].(int), true
|
||||
case "int16":
|
||||
return int(r[column].(int16)), true
|
||||
case "int32":
|
||||
return int(r[column].(int32)), true
|
||||
case "int64":
|
||||
return int(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseInt(r[column].(string), 10, 0); err == nil {
|
||||
return int(value), true
|
||||
}
|
||||
case "uint":
|
||||
return int(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return int(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return int(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return int(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return int(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Int16(column string) int16 {
|
||||
value, _ := r.Int16Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Int16Safe(column string) (int16, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return int16(r[column].(int)), true
|
||||
case "int16":
|
||||
return r[column].(int16), true
|
||||
case "int32":
|
||||
return int16(r[column].(int32)), true
|
||||
case "int64":
|
||||
return int16(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseInt(r[column].(string), 10, 16); err == nil {
|
||||
return int16(value), true
|
||||
}
|
||||
case "uint":
|
||||
return int16(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return int16(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return int16(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return int16(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return int16(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Int32(column string) int32 {
|
||||
value, _ := r.Int32Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Int32Safe(column string) (int32, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return int32(r[column].(int)), true
|
||||
case "int16":
|
||||
return int32(r[column].(int16)), true
|
||||
case "int32":
|
||||
return r[column].(int32), true
|
||||
case "int64":
|
||||
return int32(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseInt(r[column].(string), 10, 32); err == nil {
|
||||
return int32(value), true
|
||||
}
|
||||
case "uint":
|
||||
return int32(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return int32(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return int32(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return int32(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return int32(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Int64(column string) int64 {
|
||||
value, _ := r.Int64Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Int64Safe(column string) (int64, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return int64(r[column].(int)), true
|
||||
case "int16":
|
||||
return int64(r[column].(int16)), true
|
||||
case "int32":
|
||||
return int64(r[column].(int32)), true
|
||||
case "int64":
|
||||
return r[column].(int64), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseInt(r[column].(string), 10, 64); err == nil {
|
||||
return value, true
|
||||
}
|
||||
case "uint":
|
||||
return int64(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return int64(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return int64(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return int64(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return int64(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) String(column string) string {
|
||||
value, _ := r.StringSafe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) StringSafe(column string) (string, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "string":
|
||||
return r[column].(string), true
|
||||
default:
|
||||
return fmt.Sprint(r[column]), true
|
||||
}
|
||||
}
|
||||
|
||||
return "", false
|
||||
}
|
||||
|
||||
func (r Record) TypeOf(column string) (reflect.Type, bool) {
|
||||
if r[column] != nil {
|
||||
return reflect.TypeOf(r[column]), true
|
||||
}
|
||||
|
||||
return nil, false
|
||||
}
|
||||
|
||||
func (r Record) Uint(column string) uint {
|
||||
value, _ := r.UintSafe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) UintSafe(column string) (uint, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return uint(r[column].(int)), true
|
||||
case "int16":
|
||||
return uint(r[column].(int16)), true
|
||||
case "int32":
|
||||
return uint(r[column].(int32)), true
|
||||
case "int64":
|
||||
return uint(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseUint(r[column].(string), 10, 0); err == nil {
|
||||
return uint(value), true
|
||||
}
|
||||
case "uint":
|
||||
return r[column].(uint), true
|
||||
case "uint8":
|
||||
return uint(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return uint(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return uint(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return uint(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Uint8(column string) uint8 {
|
||||
value, _ := r.Uint8Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Uint8Safe(column string) (uint8, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return uint8(r[column].(int)), true
|
||||
case "int16":
|
||||
return uint8(r[column].(int16)), true
|
||||
case "int32":
|
||||
return uint8(r[column].(int32)), true
|
||||
case "int64":
|
||||
return uint8(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseUint(r[column].(string), 10, 16); err == nil {
|
||||
return uint8(value), true
|
||||
}
|
||||
case "uint":
|
||||
return uint8(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return r[column].(uint8), true
|
||||
case "uint16":
|
||||
return uint8(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return uint8(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return uint8(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Uint16(column string) uint16 {
|
||||
value, _ := r.Uint16Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Uint16Safe(column string) (uint16, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return uint16(r[column].(int)), true
|
||||
case "int16":
|
||||
return uint16(r[column].(int16)), true
|
||||
case "int32":
|
||||
return uint16(r[column].(int32)), true
|
||||
case "int64":
|
||||
return uint16(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseUint(r[column].(string), 10, 16); err == nil {
|
||||
return uint16(value), true
|
||||
}
|
||||
case "uint":
|
||||
return uint16(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return uint16(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return r[column].(uint16), true
|
||||
case "uint32":
|
||||
return uint16(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return uint16(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Uint32(column string) uint32 {
|
||||
value, _ := r.Uint32Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Uint32Safe(column string) (uint32, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return uint32(r[column].(int)), true
|
||||
case "int16":
|
||||
return uint32(r[column].(int16)), true
|
||||
case "int32":
|
||||
return uint32(r[column].(int32)), true
|
||||
case "int64":
|
||||
return uint32(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseUint(r[column].(string), 10, 32); err == nil {
|
||||
return uint32(value), true
|
||||
}
|
||||
case "uint":
|
||||
return uint32(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return uint32(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return uint32(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return r[column].(uint32), true
|
||||
case "uint64":
|
||||
return uint32(r[column].(uint64)), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func (r Record) Uint64(column string) uint64 {
|
||||
value, _ := r.Uint64Safe(column)
|
||||
return value
|
||||
}
|
||||
|
||||
func (r Record) Uint64Safe(column string) (uint64, bool) {
|
||||
if t, ok := r.TypeOf(column); ok {
|
||||
switch t.Name() {
|
||||
case "bool":
|
||||
if r[column].(bool) {
|
||||
return 1, true
|
||||
} else {
|
||||
return 0, true
|
||||
}
|
||||
case "int":
|
||||
return uint64(r[column].(int)), true
|
||||
case "int16":
|
||||
return uint64(r[column].(int16)), true
|
||||
case "int32":
|
||||
return uint64(r[column].(int32)), true
|
||||
case "int64":
|
||||
return uint64(r[column].(int64)), true
|
||||
case "string":
|
||||
if value, err := strconv.ParseUint(r[column].(string), 10, 64); err == nil {
|
||||
return value, true
|
||||
}
|
||||
case "uint":
|
||||
return uint64(r[column].(uint)), true
|
||||
case "uint8":
|
||||
return uint64(r[column].(uint8)), true
|
||||
case "uint16":
|
||||
return uint64(r[column].(uint16)), true
|
||||
case "uint32":
|
||||
return uint64(r[column].(uint32)), true
|
||||
case "uint64":
|
||||
return r[column].(uint64), true
|
||||
}
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
Reference in New Issue
Block a user