/
serialize.go
95 lines (82 loc) · 2.43 KB
/
serialize.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package ccserialize
import (
"reflect"
"strconv"
"strings"
)
func Serialize(input interface{}) string {
switch reflect.ValueOf(input).Kind() {
case reflect.Int:
return strconv.Itoa(input.(int))
case reflect.Uint8:
return Serialize(int(input.(uint8)))
case reflect.Int8:
return Serialize(int(input.(int8)))
case reflect.Uint16:
return Serialize(int(input.(uint16)))
case reflect.Int16:
return Serialize(int(input.(int16)))
case reflect.Uint32:
return Serialize(int64(input.(uint32)))
case reflect.Int32:
return Serialize(int(input.(int32)))
case reflect.Int64:
return strconv.FormatInt(input.(int64), 10)
case reflect.Float64:
return strconv.FormatFloat(input.(float64), 'f', 6, 64)
case reflect.String:
return "\"" + strings.Replace(input.(string), "\"", "\\\"", -1) + "\""
case reflect.Map:
t := reflect.TypeOf(input)
v := reflect.ValueOf(input)
it := reflect.TypeOf((*interface{})(nil)).Elem()
m := reflect.MakeMap(reflect.MapOf(t.Key(), it))
for _, mk := range v.MapKeys() {
m.SetMapIndex(mk, v.MapIndex(mk))
}
return mapSerialize(m.Interface().(map[string]interface{}))
case reflect.Slice:
s := reflect.ValueOf(input)
ret := make([]interface{}, s.Len())
for i := 0; i < s.Len(); i++ {
ret[i] = s.Index(i).Interface()
}
return arraySerialize(ret)
case reflect.Struct:
return structSerialize(input)
default:
panic("Attempt to serialize unsupported type.")
}
}
func structSerialize(input interface{}) string {
serializedString := "{"
intStr := reflect.ValueOf(input)
str := reflect.TypeOf(input)
for i := 0; i < str.NumField(); i++ {
f := intStr.Field(i)
keyName := str.Field(i).Name
if str.Field(i).Tag.Get("ccserialize") != "" {
keyName = str.Field(i).Tag.Get("ccserialize")
}
if keyName == "-" || !f.CanInterface() {
continue
}
serializedString = serializedString + "[\"" + strings.ToLower(keyName) + "\"]="
serializedString = serializedString + Serialize(f.Interface()) + ","
}
return serializedString + "}"
}
func arraySerialize(input []interface{}) string {
serializedString := "{"
for k, v := range input {
serializedString = serializedString + "[" + strconv.Itoa(k+1) + "]=" + Serialize(v) + ","
}
return serializedString + "}"
}
func mapSerialize(input map[string]interface{}) string {
serializedString := "{"
for k, v := range input {
serializedString = serializedString + "[\"" + k + "\"]=" + Serialize(v) + ","
}
return serializedString + "}"
}