-
Notifications
You must be signed in to change notification settings - Fork 0
/
utils.go
183 lines (166 loc) · 4.22 KB
/
utils.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
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
176
177
178
179
180
181
182
183
// ,+---+
// +---+´| HASHBOX SOURCE
// | # | | Copyright 2015-2024
// +---+´
// Hashbox core, version 0.1
package core
import (
"github.com/fredli74/bytearray"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"sync"
"syscall"
"time"
)
func ReadBytes(r io.Reader, data []byte) int {
if n, err := io.ReadFull(r, data); err != nil {
panic(err)
} else {
return n
}
}
func ReadUint8(r io.Reader, data *uint8) int {
var b [1]byte
n := ReadBytes(r, b[:])
*data = b[0]
return n
}
func ReadUint16(r io.Reader, data *uint16) int {
var b [2]byte
n := ReadBytes(r, b[:])
*data = uint16(b[1]) | uint16(b[0])<<8
return n
}
func ReadUint32(r io.Reader, data *uint32) int {
var b [4]byte
n := ReadBytes(r, b[:])
*data = uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
return n
}
func ReadInt64(r io.Reader, data *int64) int {
var b [8]byte
n := ReadBytes(r, b[:])
*data = int64(uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 | uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56)
return n
}
func WriteBytes(w io.Writer, data []byte) int {
if n, err := w.Write(data); err != nil {
panic(err)
} else {
return n
}
}
func WriteUint8(w io.Writer, data uint8) int {
var b [1]byte = [1]byte{data}
return WriteBytes(w, b[:])
}
func WriteUint16(w io.Writer, data uint16) int {
var b [2]byte = [2]byte{byte(data >> 8), byte(data)}
return WriteBytes(w, b[:])
}
func WriteUint32(w io.Writer, data uint32) int {
var b [4]byte = [4]byte{byte(data >> 24), byte(data >> 16), byte(data >> 8), byte(data)}
return WriteBytes(w, b[:])
}
func WriteInt64(w io.Writer, data int64) int {
var b [8]byte = [8]byte{byte(data >> 56), byte(data >> 48), byte(data >> 40), byte(data >> 32), byte(data >> 24), byte(data >> 16), byte(data >> 8), byte(data)}
return WriteBytes(w, b[:])
}
func CopyOrPanic(dst io.Writer, src io.Reader) int {
written, err := io.Copy(dst, src)
if err != nil {
panic(err)
}
return int(written)
}
func CopyNOrPanic(dst io.Writer, src io.Reader, n int) int {
written, err := io.CopyN(dst, src, int64(n))
if err != nil {
panic(err)
}
return int(written)
}
const LOGTIMEFORMAT string = "20060102 15:04:05"
const (
LogError = iota
LogWarning
LogInfo
LogDebug
LogTrace
)
var LogLevel int = LogInfo
var logMarks []string = []string{"!", "*", ".", "(", "?"}
var LogMutex sync.Mutex
func Log(level int, format string, a ...interface{}) {
LogMutex.Lock()
defer LogMutex.Unlock()
if level <= LogLevel {
fmt.Printf("%s %s "+format+"\n", append([]interface{}{time.Now().UTC().Format(LOGTIMEFORMAT), logMarks[level]}, a...)...)
}
}
var humanUnitName []string = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"}
var shortHumanUnitName []string = []string{"B", "K", "M", "G", "T", "P", "E"}
func unitize(size int64, limit int) (floatSize float64, unit int, precision int) {
floatSize = float64(size)
for ; unit < limit && floatSize > 1000; floatSize /= 1024 {
unit++
}
if unit > 0 && floatSize < 10 {
precision = 2
} else if unit > 0 && floatSize < 100 {
precision = 1
}
return floatSize, unit, precision
}
func HumanSize(size int64) string {
s, u, p := unitize(size, len(humanUnitName))
return fmt.Sprintf("%.*f %s", p, s, humanUnitName[u])
}
func ShortHumanSize(size int64) string {
s, u, p := unitize(size, len(shortHumanUnitName))
return fmt.Sprintf("%.*f%s", p, s, shortHumanUnitName[u])
}
const MaxUint = ^uint(0)
const MinUint = 0
const MaxInt = int(MaxUint >> 1)
const MinInt = -MaxInt - 1
func BytesInt64(bytes []byte) (v int64) {
for _, b := range bytes {
v <<= 8
v |= int64(b)
}
return v
}
func LimitInt(big int64) (v int) {
v = MaxInt
if big < int64(v) {
v = int(big)
}
return v
}
func ExpandEnv(s string) string {
return os.Expand(s, func(key string) string {
if key == "$" {
return key
}
v, _ := syscall.Getenv(key)
return v
})
}
func SplitPath(path string) []string {
list := strings.Split(filepath.Clean(path), string(filepath.Separator))
filtered := list[:0]
for _, l := range list {
if l != "" {
filtered = append(filtered, l)
}
}
return filtered
}
func MemoryStats() string {
a, _, _, m, u := bytearray.Stats()
return fmt.Sprintf("Memory stats: %d slabs, %s allocated, %s used", a, ShortHumanSize(m), ShortHumanSize(u))
}