f330a92a2b
- Marked the Cache Implementation as complete in TODO.md, confirming all tasks are finished with comprehensive integration tests. - Updated cache.go to provide a thread-safe in-memory cache for Robot instances, improving performance and reliability. - Enhanced the Load method to include pagination and configurable model name, ensuring efficient data handling. - Added detailed comments and structured code for better readability and maintainability across the cache implementation. - Improved validation and error handling in various utility functions to ensure robustness in data processing.
146 lines
2.9 KiB
Go
146 lines
2.9 KiB
Go
package utils
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
)
|
|
|
|
// ToJSON converts any value to JSON string
|
|
func ToJSON(v interface{}) (string, error) {
|
|
data, err := json.Marshal(v)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(data), nil
|
|
}
|
|
|
|
// FromJSON parses JSON string to target
|
|
func FromJSON(jsonStr string, target interface{}) error {
|
|
return json.Unmarshal([]byte(jsonStr), target)
|
|
}
|
|
|
|
// ToMap converts struct to map[string]interface{}
|
|
func ToMap(v interface{}) (map[string]interface{}, error) {
|
|
data, err := json.Marshal(v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var result map[string]interface{}
|
|
if err := json.Unmarshal(data, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// FromMap converts map to struct
|
|
func FromMap(m map[string]interface{}, target interface{}) error {
|
|
data, err := json.Marshal(m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return json.Unmarshal(data, target)
|
|
}
|
|
|
|
// ToString converts any value to string
|
|
func ToString(v interface{}) string {
|
|
switch val := v.(type) {
|
|
case string:
|
|
return val
|
|
case []byte:
|
|
return string(val)
|
|
case int, int8, int16, int32, int64:
|
|
return fmt.Sprintf("%d", val)
|
|
case uint, uint8, uint16, uint32, uint64:
|
|
return fmt.Sprintf("%d", val)
|
|
case float32, float64:
|
|
return fmt.Sprintf("%f", val)
|
|
case bool:
|
|
return fmt.Sprintf("%t", val)
|
|
default:
|
|
// Fallback to JSON
|
|
if str, err := ToJSON(v); err == nil {
|
|
return str
|
|
}
|
|
return fmt.Sprintf("%v", v)
|
|
}
|
|
}
|
|
|
|
// MergeMap merges source map into target map (shallow copy)
|
|
func MergeMap(target, source map[string]interface{}) map[string]interface{} {
|
|
if target == nil {
|
|
target = make(map[string]interface{})
|
|
}
|
|
for k, v := range source {
|
|
target[k] = v
|
|
}
|
|
return target
|
|
}
|
|
|
|
// CloneMap creates a shallow copy of a map
|
|
func CloneMap(m map[string]interface{}) map[string]interface{} {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
result := make(map[string]interface{}, len(m))
|
|
for k, v := range m {
|
|
result[k] = v
|
|
}
|
|
return result
|
|
}
|
|
|
|
// GetString safely gets a string value from map
|
|
func GetString(m map[string]interface{}, key string) string {
|
|
if m == nil {
|
|
return ""
|
|
}
|
|
if v, ok := m[key]; ok && v != nil {
|
|
return ToString(v)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// GetBool safely gets a bool value from map
|
|
func GetBool(m map[string]interface{}, key string) bool {
|
|
if m == nil {
|
|
return false
|
|
}
|
|
if v, ok := m[key]; ok && v != nil {
|
|
switch b := v.(type) {
|
|
case bool:
|
|
return b
|
|
case int:
|
|
return b != 0
|
|
case int64:
|
|
return b != 0
|
|
case float64:
|
|
return b != 0
|
|
case string:
|
|
return b == "true" || b == "1"
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// GetInt safely gets an int value from map
|
|
func GetInt(m map[string]interface{}, key string) int {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
if v, ok := m[key]; ok && v != nil {
|
|
switch n := v.(type) {
|
|
case int:
|
|
return n
|
|
case int64:
|
|
return int(n)
|
|
case float64:
|
|
return int(n)
|
|
case string:
|
|
var i int
|
|
fmt.Sscanf(n, "%d", &i)
|
|
return i
|
|
}
|
|
}
|
|
return 0
|
|
}
|