-
Notifications
You must be signed in to change notification settings - Fork 101
/
util.go
126 lines (113 loc) · 2.31 KB
/
util.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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package common
import (
"encoding/base64"
"fmt"
"github.com/fatih/structs"
"net/url"
"reflect"
"strings"
)
func Base64StdDecode(s string) (string, error) {
s = strings.TrimSpace(s)
saver := s
if len(s)%4 > 0 {
s += strings.Repeat("=", 4-len(s)%4)
}
raw, err := base64.StdEncoding.DecodeString(s)
if err != nil {
return saver, err
}
return string(raw), nil
}
func BoolToString(b bool) string {
if b {
return "true"
}
return "false"
}
func StringToBool(s string) bool {
switch strings.ToLower(s) {
case "true", "yes", "1", "y":
return true
default:
return false
}
}
func Base64URLDecode(s string) (string, error) {
s = strings.TrimSpace(s)
saver := s
if len(s)%4 > 0 {
s += strings.Repeat("=", 4-len(s)%4)
}
raw, err := base64.URLEncoding.DecodeString(s)
if err != nil {
return saver, err
}
return string(raw), nil
}
func ObjectToKV(v interface{}, tagName string) (kv []string) {
a := structs.New(v)
if tagName != "" {
a.TagName = tagName
}
return MapToKV(a.Map())
}
func MapToKV(m map[string]interface{}) (kv []string) {
val := reflect.ValueOf(m)
keys := val.MapKeys()
for _, k := range keys {
v := val.MapIndex(k)
switch v := v.Interface().(type) {
case map[string]interface{}:
subKV := MapToKV(v)
for _, s := range subKV {
kv = append(kv, fmt.Sprintf("%v.%v", k.String(), s))
}
default:
kv = append(kv, fmt.Sprintf("%v=%v", k.String(), v))
}
}
return kv
}
func StringsToSet(s []string) map[string]struct{} {
m := make(map[string]struct{})
for _, v := range s {
m[v] = struct{}{}
}
return m
}
func StringsMapToSet(s []string, mapper func(s string) string) map[string]struct{} {
m := make(map[string]struct{})
for _, v := range s {
m[mapper(v)] = struct{}{}
}
return m
}
func SliceUint64toUint32(from []uint64) (to []uint32) {
to = make([]uint32, len(from)*2)
for i := range from {
to[i*2+1] = uint32(from[i] & 0xffffffff)
to[i*2] = uint32((from[i] & 0xffffffff00000000) >> 32)
}
return to
}
func SetValue(values *url.Values, key string, value string) {
if value == "" {
return
}
values.Set(key, value)
}
func Max(a, b int) int {
if a > b {
return a
}
return b
}
func MustGetMapKeys(m interface{}) (keys []string) {
v := reflect.ValueOf(m)
vKeys := v.MapKeys()
for _, k := range vKeys {
keys = append(keys, k.String())
}
return keys
}