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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
package saggytrousers
import (
"fmt"
"strings"
"errors"
"reflect"
"math"
"strconv"
)
// Given a map, return all the values as an array.
func GetMapValues[K comparable, V any](m map[K]V) []V {
vs := []V{}
for _, v := range m {
vs = append(vs, v)
}
return vs
}
// Check if a given value is found in a slice.
func InSlice[T comparable](s []T, v T) bool {
for _, sv := range s {
if sv == v {
return true
}
}
return false
}
// A concrete instantiation for any since any does not implement comparable.
func InSliceAny(s []any, v any) bool {
for _, sv := range s {
if sv == v {
return true
}
}
return false
}
func SliceEq[T comparable](fst, snd []T) bool {
if len(fst) != len(snd) {
return false
}
for i := 0; i < len(fst); i++ {
if fst[i] != snd[i] {
return false
}
}
return true
}
// Create a filepath, consisting of a directory, a subdirectory within that
// called the `saveDir`, a filename which may contain an instance of `%s`, and
// a key which replaces the %s in the filename.
func CreateFilepath(dir, saveDir, filename, key string) string {
name := CreateFilename(filename, key)
// Add directory
ret := fmt.Sprintf("%s/%s/%s", dir, saveDir, name)
return ret
}
func CreateFilename(filename, key string) string {
name := fmt.Sprintf(filename, key)
// Remove illegal characters
name = strings.TrimRight(name, "\n")
name = strings.ReplaceAll(name, " ", "-")
name = strings.ReplaceAll(name, "/", "-")
name = strings.ReplaceAll(name, "\\", "-")
name = strings.ReplaceAll(name, ":", "-")
name = strings.ReplaceAll(name, ";", "-")
name = strings.ReplaceAll(name, "!", "-")
name = strings.ReplaceAll(name, "?", "-")
return name
}
// Take input of CreateFilename or something similar, and trim it to 20 for
// making a sheet name.
func MakeValidSheetName(s string) string {
var max int
if len(s) < 20 {
max = len(s)
} else {
max = 20
}
return s[0:max]
}
// Downcasts a []any to a []T. Returns error if any fail.
func Downcast[T any](vs []any) ([]T, error) {
var ret []T
for i, v := range vs {
cv, ok := v.(T)
if !ok {
errmesg := fmt.Sprintf("Downcast: failed conv at idx %v for value %v type %T", i, v, v)
return ret, errors.New(errmesg)
}
ret = append(ret, cv)
}
return ret, nil
}
func DowncastF64(vs []any) ([]float64, error) {
var ret []float64
for i, v := range vs {
cv, err := ConvertF64(v)
if err != nil {
errmesg := fmt.Sprintf("Downcast: failed conv at idx %v for value %v type %T", i, v, v)
return ret, errors.New(errmesg)
}
ret = append(ret, cv)
}
return ret, nil
}
// A conversion function to f64 from any. Why this isn't in the standard god
// knows. From StackOverflow question 20767724.
var floatType = reflect.TypeOf(float64(0))
var stringType = reflect.TypeOf("")
func ConvertF64(unkn any) (float64, error) {
switch i := unkn.(type) {
case float64:
return i, nil
case float32:
return float64(i), nil
case int64:
return float64(i), nil
case int32:
return float64(i), nil
case int:
return float64(i), nil
case uint64:
return float64(i), nil
case uint32:
return float64(i), nil
case uint:
return float64(i), nil
case string:
return strconv.ParseFloat(i, 64)
default:
v := reflect.ValueOf(unkn)
v = reflect.Indirect(v)
if v.Type().ConvertibleTo(floatType) {
fv := v.Convert(floatType)
return fv.Float(), nil
} else if v.Type().ConvertibleTo(stringType) {
sv := v.Convert(stringType)
s := sv.String()
return strconv.ParseFloat(s, 64)
} else {
return math.NaN(), fmt.Errorf("Can't convert %v to float64", v.Type())
}
}
}
// Get a given _column_ from a set of rows. This is used to get columns from
// GetRows, which is potentially faster than calling GetColumns.
func TransmogrifyRows(rows [][]any, index int) []any {
var ret []any
for _, row := range rows {
ret = append(ret, row[index])
}
return ret
}
// Process a string, removing spaces, making all lowercase, etc. so that we get
// easily `switch`-able strings.
func ProcessStr(str string) string {
ret := strings.TrimSuffix(str, " ")
ret = strings.ToLower(str)
return ret
}
|
