90b52eaf22
- Marked Phase 1: Types & Interfaces as complete with 88.4% test coverage and all tests passing. - Updated Phase 2: Skeleton Implementation status to complete, confirming all packages compile successfully without circular dependencies. - Checked off all tasks under both phases, indicating full implementation of types, interfaces, and skeleton structures.
91 lines
1.9 KiB
Go
91 lines
1.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
|
|
}
|