154 lines
3.5 KiB
V
154 lines
3.5 KiB
V
module time
|
|
|
|
// A lot of these are taken from the Go library.
|
|
pub type Duration = i64
|
|
|
|
@[markused]
|
|
pub const nanosecond = Duration(1)
|
|
pub const microsecond = Duration(1000 * nanosecond)
|
|
pub const millisecond = Duration(1000 * microsecond)
|
|
pub const second = Duration(1000 * millisecond)
|
|
pub const minute = Duration(60 * second)
|
|
pub const hour = Duration(60 * minute)
|
|
// day = Duration(24 * hour)
|
|
pub const infinite = Duration(i64(9223372036854775807))
|
|
|
|
// nanoseconds returns the duration as an integer number of nanoseconds.
|
|
pub fn (d Duration) nanoseconds() i64 {
|
|
return i64(d)
|
|
}
|
|
|
|
// microseconds returns the duration as an integer number of microseconds.
|
|
pub fn (d Duration) microseconds() i64 {
|
|
return i64(d) / microsecond
|
|
}
|
|
|
|
// milliseconds returns the duration as an integer number of milliseconds.
|
|
pub fn (d Duration) milliseconds() i64 {
|
|
return i64(d) / millisecond
|
|
}
|
|
|
|
// The following functions return floating point numbers because it's common to
|
|
// consider all of them in sub-one intervals
|
|
// seconds returns the duration as a floating point number of seconds.
|
|
pub fn (d Duration) seconds() f64 {
|
|
return f64(d) / f64(second)
|
|
}
|
|
|
|
// minutes returns the duration as a floating point number of minutes.
|
|
pub fn (d Duration) minutes() f64 {
|
|
return f64(d) / f64(minute)
|
|
}
|
|
|
|
// hours returns the duration as a floating point number of hours.
|
|
pub fn (d Duration) hours() f64 {
|
|
return f64(d) / f64(hour)
|
|
}
|
|
|
|
// days returns the duration as a floating point number of days.
|
|
pub fn (d Duration) days() f64 {
|
|
return f64(d) / f64(hour * 24)
|
|
}
|
|
|
|
fn duration_pad2(n i64) string {
|
|
if n < 10 {
|
|
return '0' + n.str()
|
|
}
|
|
return n.str()
|
|
}
|
|
|
|
fn duration_pad3(n i64) string {
|
|
if n < 10 {
|
|
return '00' + n.str()
|
|
}
|
|
if n < 100 {
|
|
return '0' + n.str()
|
|
}
|
|
return n.str()
|
|
}
|
|
|
|
// str pretty prints the duration
|
|
//
|
|
// ```
|
|
// h:m:s // 5:02:33
|
|
// m:s.mi<s> // 2:33.015
|
|
// s.mi<s> // 33.015s
|
|
// mi.mc<ms> // 15.007ms
|
|
// mc.ns<ns> // 7.234us
|
|
// ns<ns> // 234ns
|
|
// ```
|
|
pub fn (d Duration) str() string {
|
|
if d == infinite {
|
|
return 'inf'
|
|
}
|
|
mut sign := ''
|
|
mut t := i64(d)
|
|
if t < 0 {
|
|
sign = '-'
|
|
t = -t
|
|
}
|
|
hr := t / hour
|
|
t -= hr * hour
|
|
min := t / minute
|
|
t -= min * minute
|
|
sec := t / second
|
|
t -= sec * second
|
|
ms := t / millisecond
|
|
t -= ms * millisecond
|
|
us := t / microsecond
|
|
t -= us * microsecond
|
|
ns := t
|
|
|
|
if hr > 0 {
|
|
return sign + hr.str() + ':' + duration_pad2(min) + ':' + duration_pad2(sec)
|
|
}
|
|
if min > 0 {
|
|
return sign + min.str() + ':' + duration_pad2(sec) + '.' + duration_pad3(ms)
|
|
}
|
|
if sec > 0 {
|
|
return sign + sec.str() + '.' + duration_pad3(ms) + 's'
|
|
}
|
|
if ms > 0 {
|
|
return sign + ms.str() + '.' + duration_pad3(us) + 'ms'
|
|
}
|
|
if us > 0 {
|
|
return sign + us.str() + '.' + duration_pad3(ns) + 'us'
|
|
}
|
|
return sign + ns.str() + 'ns'
|
|
}
|
|
|
|
// debug returns a detailed breakdown of the Duration, as: 'Duration: - 50days, 4h, 3m, 7s, 541ms, 78us, 9ns'.
|
|
pub fn (d Duration) debug() string {
|
|
mut res := []string{}
|
|
mut x := i64(d)
|
|
mut sign := ''
|
|
if x < 0 {
|
|
sign = '- '
|
|
x = -x
|
|
}
|
|
for label, v in {
|
|
'days': 24 * hour
|
|
'h': hour
|
|
'm': minute
|
|
's': second
|
|
'ms': millisecond
|
|
'us': microsecond
|
|
} {
|
|
if x > v {
|
|
xx := x / v
|
|
x = x % v
|
|
res << xx.str() + label
|
|
}
|
|
}
|
|
if x > 0 {
|
|
res << x.str() + 'ns'
|
|
}
|
|
return 'Duration: ' + sign + res.join(', ')
|
|
}
|
|
|
|
// times allows you to return fractional unit durations, based on an existing duration.
|
|
// For example, you can: `half_an_hour := time.hour.times(0.5)` .
|
|
pub fn (d Duration) times(x f64) Duration {
|
|
return f64(d) * x
|
|
}
|