gotosocial/vendor/codeberg.org/gruf/go-bytesize/bytesize.go
kim 1d999712e6
[feature] update config types to use bytesize.Size (#828)
* update config size types to use bytesize.Size

* submit unchecked-out file ... 🤦

* fix bytesize config var decoding

* bump bytesize version

* update kim's libraries in readme

* update envparse.sh to output more useful errors

* improve envparse.sh

* remove reliance on jq

* instead, use uint64 for bytesize flag types

* remove redundant type

* fix viper unmarshaling

* Update envparsing.sh

* fix envparsing test

Signed-off-by: kim <grufwub@gmail.com>
Co-authored-by: tobi <31960611+tsmethurst@users.noreply.github.com>
2022-09-29 21:50:43 +01:00

357 lines
7.2 KiB
Go

package bytesize
import (
"errors"
"math/bits"
"unsafe"
)
const (
// SI units
KB Size = 1e3
MB Size = 1e6
GB Size = 1e9
TB Size = 1e12
PB Size = 1e15
EB Size = 1e18
// IEC units
KiB Size = 1024
MiB Size = KiB * 1024
GiB Size = MiB * 1024
TiB Size = GiB * 1024
PiB Size = TiB * 1024
EiB Size = PiB * 1024
)
var (
// ErrInvalidUnit is returned when an invalid IEC/SI is provided.
ErrInvalidUnit = errors.New("bytesize: invalid unit")
// ErrInvalidFormat is returned when an invalid size value is provided.
ErrInvalidFormat = errors.New("bytesize: invalid format")
// iecpows is a precomputed table of 1024^n.
iecpows = [...]float64{
float64(KiB),
float64(MiB),
float64(GiB),
float64(TiB),
float64(PiB),
float64(EiB),
}
// sipows is a precomputed table of 1000^n.
sipows = [...]float64{
float64(KB),
float64(MB),
float64(GB),
float64(TB),
float64(PB),
float64(EB),
}
// bvals is a precomputed table of IEC unit values.
iecvals = [...]Size{
'k': KiB,
'K': KiB,
'M': MiB,
'G': GiB,
'T': TiB,
'P': PiB,
'E': EiB,
}
// sivals is a precomputed table of SI unit values.
sivals = [...]Size{
// ASCII numbers _aren't_ valid SI unit values,
// BUT if the space containing a possible unit
// char is checked with this table -- it is valid
// to provide no unit char so unit=1 works.
'0': 1,
'1': 1,
'2': 1,
'3': 1,
'4': 1,
'5': 1,
'6': 1,
'7': 1,
'8': 1,
'9': 1,
'k': KB,
'K': KB,
'M': MB,
'G': GB,
'T': TB,
'P': PB,
'E': EB,
}
)
// Size is a casting for uint64 types that provides formatting
// methods for byte sizes in both IEC and SI units.
type Size uint64
// ParseSize will parse a valid Size from given string. Both IEC and SI units are supported.
func ParseSize(s string) (Size, error) {
// Parse units from string
unit, l, err := parseUnit(s)
if err != nil {
return 0, err
}
// Parse remaining string as float
f, n, err := atof64(s[:l])
if err != nil || n != l {
return 0, ErrInvalidFormat
}
return Size(f) * unit, nil
}
// Set implements flag.Value{}.
func (sz *Size) Set(in string) error {
s, err := ParseSize(in)
if err != nil {
return err
}
*sz = s
return nil
}
// MarshalText implements encoding.TextMarshaler{}.
func (sz *Size) MarshalText() ([]byte, error) {
const maxLen = 7 // max IEC string length
return sz.AppendFormatIEC(make([]byte, 0, maxLen)), nil
}
// UnmarshalText implements encoding.TextUnmarshaler{}.
func (sz *Size) UnmarshalText(text []byte) error {
return sz.Set(*(*string)(unsafe.Pointer(&text)))
}
// AppendFormat defaults to using Size.AppendFormatIEC().
func (sz Size) AppendFormat(dst []byte) []byte {
return sz.AppendFormatIEC(dst) // default
}
// AppendFormatSI will append SI formatted size to 'dst'.
func (sz Size) AppendFormatSI(dst []byte) []byte {
if uint64(sz) < 1000 {
dst = itoa(dst, uint64(sz))
dst = append(dst, 'B')
return dst
} // above is fast-path, .appendFormat() is outlined
return sz.appendFormat(dst, 1000, &sipows, "B")
}
// AppendFormatIEC will append IEC formatted size to 'dst'.
func (sz Size) AppendFormatIEC(dst []byte) []byte {
if uint64(sz) < 1024 {
dst = itoa(dst, uint64(sz))
dst = append(dst, 'B')
return dst
} // above is fast-path, .appendFormat() is outlined
return sz.appendFormat(dst, 1024, &iecpows, "iB")
}
// appendFormat will append formatted Size to 'dst', depending on base, powers table and single unit suffix.
func (sz Size) appendFormat(dst []byte, base uint64, pows *[6]float64, sunit string) []byte {
const (
// min "small" unit threshold
min = 0.75
// binary unit chars.
units = `kMGTPE`
)
// Larger number: get value of
// i / unit size. We have a 'min'
// threshold after which we prefer
// using the unit 1 down
n := bits.Len64(uint64(sz)) / 10
f := float64(sz) / pows[n-1]
if f < min {
f *= float64(base)
n--
}
// Append formatted float with units
dst = ftoa(dst, f)
dst = append(dst, units[n-1])
dst = append(dst, sunit...)
return dst
}
// StringSI returns an SI unit string format of Size.
func (sz Size) StringSI() string {
const maxLen = 6 // max SI string length
b := sz.AppendFormatSI(make([]byte, 0, maxLen))
return *(*string)(unsafe.Pointer(&b))
}
// StringIEC returns an IEC unit string format of Size.
func (sz Size) StringIEC() string {
const maxLen = 7 // max IEC string length
b := sz.AppendFormatIEC(make([]byte, 0, maxLen))
return *(*string)(unsafe.Pointer(&b))
}
// String returns a string format of Size, defaults to IEC unit format.
func (sz Size) String() string {
return sz.StringIEC()
}
// parseUnit will parse the byte size unit from string 's'.
func parseUnit(s string) (Size, int, error) {
// Check for string
if len(s) < 1 {
return 0, 0, ErrInvalidFormat
}
// Strip 'byte' unit suffix
if l := len(s) - 1; s[l] == 'B' {
s = s[:l]
if len(s) < 1 {
// No remaining str before unit suffix
return 0, 0, ErrInvalidFormat
}
}
// Strip IEC binary unit suffix
if l := len(s) - 1; s[l] == 'i' {
s = s[:l]
if len(s) < 1 {
// No remaining str before unit suffix
return 0, 0, ErrInvalidFormat
}
// Location of unit char.
l := len(s) - 1
c := int(s[l])
// Check valid unit char was provided
if len(iecvals) < c || iecvals[c] == 0 {
return 0, 0, ErrInvalidUnit
}
// Return parsed IEC unit size
return iecvals[c], l, nil
}
// Location of unit char.
l := len(s) - 1
c := int(s[l])
switch {
// Check valid unit char provided
case len(sivals) < c || sivals[c] == 0:
return 0, 0, ErrInvalidUnit
// No unit char (only ascii number)
case sivals[c] == 1:
l++
}
// Return parsed SI unit size
return sivals[c], l, nil
}
// ftoa appends string formatted 'f' to 'dst', assumed < ~800.
func ftoa(dst []byte, f float64) []byte {
switch i := uint64(f); {
// Append with 2 d.p.
case i < 10:
f *= 10
// Calculate next dec. value
d1 := uint8(uint64(f) % 10)
f *= 10
// Calculate next dec. value
d2 := uint8(uint64(f) % 10)
// Round the final value
if uint64(f*10)%10 > 4 {
d2++
// Overflow, incr 'd1'
if d2 == 10 {
d2 = 0
d1++
// Overflow, incr 'i'
if d1 == 10 {
d1 = 0
i++
}
}
}
// Append decimal value
dst = itoa(dst, i)
dst = append(dst,
'.',
'0'+d1,
'0'+d2,
)
// Append with 1 d.p.
case i < 100:
f *= 10
// Calculate next dec. value
d1 := uint8(uint64(f) % 10)
// Round the final value
if uint64(f*10)%10 > 4 {
d1++
// Overflow, incr 'i'
if d1 == 10 {
d1 = 0
i++
}
}
// Append decimal value
dst = itoa(dst, i)
dst = append(dst, '.', '0'+d1)
// No decimal places
default:
dst = itoa(dst, i)
}
return dst
}
// itoa appends string formatted 'i' to 'dst'.
func itoa(dst []byte, i uint64) []byte {
// Assemble uint in reverse order.
var b [4]byte
bp := len(b) - 1
// Append integer
for i >= 10 {
q := i / 10
b[bp] = byte('0' + i - q*10)
bp--
i = q
} // i < 10
b[bp] = byte('0' + i)
return append(dst, b[bp:]...)
}
// We use the following internal strconv function usually
// used internally to parse float values, as we know that
// are value passed will always be of 64bit type, and knowing
// the returned float string length is very helpful!
//
//go:linkname atof64 strconv.atof64
func atof64(string) (float64, int, error)