patch time: Duration, Timer
This commit is contained in:
xushiwei
@@ -19,7 +19,6 @@ package time
|
||||
// llgo:skipall
|
||||
import (
|
||||
"unsafe"
|
||||
_ "unsafe"
|
||||
|
||||
"github.com/goplus/llgo/c"
|
||||
"github.com/goplus/llgo/c/time"
|
||||
@@ -620,6 +619,332 @@ func (t Time) YearDay() int {
|
||||
return yday + 1
|
||||
}
|
||||
|
||||
// A Duration represents the elapsed time between two instants
|
||||
// as an int64 nanosecond count. The representation limits the
|
||||
// largest representable duration to approximately 290 years.
|
||||
type Duration int64
|
||||
|
||||
const (
|
||||
minDuration Duration = -1 << 63
|
||||
maxDuration Duration = 1<<63 - 1
|
||||
)
|
||||
|
||||
// Common durations. There is no definition for units of Day or larger
|
||||
// to avoid confusion across daylight savings time zone transitions.
|
||||
//
|
||||
// To count the number of units in a Duration, divide:
|
||||
//
|
||||
// second := time.Second
|
||||
// fmt.Print(int64(second/time.Millisecond)) // prints 1000
|
||||
//
|
||||
// To convert an integer number of units to a Duration, multiply:
|
||||
//
|
||||
// seconds := 10
|
||||
// fmt.Print(time.Duration(seconds)*time.Second) // prints 10s
|
||||
const (
|
||||
Nanosecond Duration = 1
|
||||
Microsecond = 1000 * Nanosecond
|
||||
Millisecond = 1000 * Microsecond
|
||||
Second = 1000 * Millisecond
|
||||
Minute = 60 * Second
|
||||
Hour = 60 * Minute
|
||||
)
|
||||
|
||||
// String returns a string representing the duration in the form "72h3m0.5s".
|
||||
// Leading zero units are omitted. As a special case, durations less than one
|
||||
// second format use a smaller unit (milli-, micro-, or nanoseconds) to ensure
|
||||
// that the leading digit is non-zero. The zero duration formats as 0s.
|
||||
func (d Duration) String() string {
|
||||
// Largest time is 2540400h10m10.000000000s
|
||||
var buf [32]byte
|
||||
w := len(buf)
|
||||
|
||||
u := uint64(d)
|
||||
neg := d < 0
|
||||
if neg {
|
||||
u = -u
|
||||
}
|
||||
|
||||
if u < uint64(Second) {
|
||||
// Special case: if duration is smaller than a second,
|
||||
// use smaller units, like 1.2ms
|
||||
var prec int
|
||||
w--
|
||||
buf[w] = 's'
|
||||
w--
|
||||
switch {
|
||||
case u == 0:
|
||||
return "0s"
|
||||
case u < uint64(Microsecond):
|
||||
// print nanoseconds
|
||||
prec = 0
|
||||
buf[w] = 'n'
|
||||
case u < uint64(Millisecond):
|
||||
// print microseconds
|
||||
prec = 3
|
||||
// U+00B5 'µ' micro sign == 0xC2 0xB5
|
||||
w-- // Need room for two bytes.
|
||||
copy(buf[w:], "µ")
|
||||
default:
|
||||
// print milliseconds
|
||||
prec = 6
|
||||
buf[w] = 'm'
|
||||
}
|
||||
w, u = fmtFrac(buf[:w], u, prec)
|
||||
w = fmtInt(buf[:w], u)
|
||||
} else {
|
||||
w--
|
||||
buf[w] = 's'
|
||||
|
||||
w, u = fmtFrac(buf[:w], u, 9)
|
||||
|
||||
// u is now integer seconds
|
||||
w = fmtInt(buf[:w], u%60)
|
||||
u /= 60
|
||||
|
||||
// u is now integer minutes
|
||||
if u > 0 {
|
||||
w--
|
||||
buf[w] = 'm'
|
||||
w = fmtInt(buf[:w], u%60)
|
||||
u /= 60
|
||||
|
||||
// u is now integer hours
|
||||
// Stop at hours because days can be different lengths.
|
||||
if u > 0 {
|
||||
w--
|
||||
buf[w] = 'h'
|
||||
w = fmtInt(buf[:w], u)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if neg {
|
||||
w--
|
||||
buf[w] = '-'
|
||||
}
|
||||
|
||||
return string(buf[w:])
|
||||
}
|
||||
|
||||
// fmtFrac formats the fraction of v/10**prec (e.g., ".12345") into the
|
||||
// tail of buf, omitting trailing zeros. It omits the decimal
|
||||
// point too when the fraction is 0. It returns the index where the
|
||||
// output bytes begin and the value v/10**prec.
|
||||
func fmtFrac(buf []byte, v uint64, prec int) (nw int, nv uint64) {
|
||||
// Omit trailing zeros up to and including decimal point.
|
||||
w := len(buf)
|
||||
print := false
|
||||
for i := 0; i < prec; i++ {
|
||||
digit := v % 10
|
||||
print = print || digit != 0
|
||||
if print {
|
||||
w--
|
||||
buf[w] = byte(digit) + '0'
|
||||
}
|
||||
v /= 10
|
||||
}
|
||||
if print {
|
||||
w--
|
||||
buf[w] = '.'
|
||||
}
|
||||
return w, v
|
||||
}
|
||||
|
||||
// fmtInt formats v into the tail of buf.
|
||||
// It returns the index where the output begins.
|
||||
func fmtInt(buf []byte, v uint64) int {
|
||||
w := len(buf)
|
||||
if v == 0 {
|
||||
w--
|
||||
buf[w] = '0'
|
||||
} else {
|
||||
for v > 0 {
|
||||
w--
|
||||
buf[w] = byte(v%10) + '0'
|
||||
v /= 10
|
||||
}
|
||||
}
|
||||
return w
|
||||
}
|
||||
|
||||
// Nanoseconds returns the duration as an integer nanosecond count.
|
||||
func (d Duration) Nanoseconds() int64 { return int64(d) }
|
||||
|
||||
// Microseconds returns the duration as an integer microsecond count.
|
||||
func (d Duration) Microseconds() int64 { return int64(d) / 1e3 }
|
||||
|
||||
// Milliseconds returns the duration as an integer millisecond count.
|
||||
func (d Duration) Milliseconds() int64 { return int64(d) / 1e6 }
|
||||
|
||||
// These methods return float64 because the dominant
|
||||
// use case is for printing a floating point number like 1.5s, and
|
||||
// a truncation to integer would make them not useful in those cases.
|
||||
// Splitting the integer and fraction ourselves guarantees that
|
||||
// converting the returned float64 to an integer rounds the same
|
||||
// way that a pure integer conversion would have, even in cases
|
||||
// where, say, float64(d.Nanoseconds())/1e9 would have rounded
|
||||
// differently.
|
||||
|
||||
// Seconds returns the duration as a floating point number of seconds.
|
||||
func (d Duration) Seconds() float64 {
|
||||
sec := d / Second
|
||||
nsec := d % Second
|
||||
return float64(sec) + float64(nsec)/1e9
|
||||
}
|
||||
|
||||
// Minutes returns the duration as a floating point number of minutes.
|
||||
func (d Duration) Minutes() float64 {
|
||||
min := d / Minute
|
||||
nsec := d % Minute
|
||||
return float64(min) + float64(nsec)/(60*1e9)
|
||||
}
|
||||
|
||||
// Hours returns the duration as a floating point number of hours.
|
||||
func (d Duration) Hours() float64 {
|
||||
hour := d / Hour
|
||||
nsec := d % Hour
|
||||
return float64(hour) + float64(nsec)/(60*60*1e9)
|
||||
}
|
||||
|
||||
// Truncate returns the result of rounding d toward zero to a multiple of m.
|
||||
// If m <= 0, Truncate returns d unchanged.
|
||||
func (d Duration) Truncate(m Duration) Duration {
|
||||
if m <= 0 {
|
||||
return d
|
||||
}
|
||||
return d - d%m
|
||||
}
|
||||
|
||||
// lessThanHalf reports whether x+x < y but avoids overflow,
|
||||
// assuming x and y are both positive (Duration is signed).
|
||||
func lessThanHalf(x, y Duration) bool {
|
||||
return uint64(x)+uint64(x) < uint64(y)
|
||||
}
|
||||
|
||||
// Round returns the result of rounding d to the nearest multiple of m.
|
||||
// The rounding behavior for halfway values is to round away from zero.
|
||||
// If the result exceeds the maximum (or minimum)
|
||||
// value that can be stored in a Duration,
|
||||
// Round returns the maximum (or minimum) duration.
|
||||
// If m <= 0, Round returns d unchanged.
|
||||
func (d Duration) Round(m Duration) Duration {
|
||||
if m <= 0 {
|
||||
return d
|
||||
}
|
||||
r := d % m
|
||||
if d < 0 {
|
||||
r = -r
|
||||
if lessThanHalf(r, m) {
|
||||
return d + r
|
||||
}
|
||||
if d1 := d - m + r; d1 < d {
|
||||
return d1
|
||||
}
|
||||
return minDuration // overflow
|
||||
}
|
||||
if lessThanHalf(r, m) {
|
||||
return d - r
|
||||
}
|
||||
if d1 := d + m - r; d1 > d {
|
||||
return d1
|
||||
}
|
||||
return maxDuration // overflow
|
||||
}
|
||||
|
||||
// Abs returns the absolute value of d.
|
||||
// As a special case, math.MinInt64 is converted to math.MaxInt64.
|
||||
func (d Duration) Abs() Duration {
|
||||
switch {
|
||||
case d >= 0:
|
||||
return d
|
||||
case d == minDuration:
|
||||
return maxDuration
|
||||
default:
|
||||
return -d
|
||||
}
|
||||
}
|
||||
|
||||
// Add returns the time t+d.
|
||||
func (t Time) Add(d Duration) Time {
|
||||
dsec := int64(d / 1e9)
|
||||
nsec := t.nsec() + int32(d%1e9)
|
||||
if nsec >= 1e9 {
|
||||
dsec++
|
||||
nsec -= 1e9
|
||||
} else if nsec < 0 {
|
||||
dsec--
|
||||
nsec += 1e9
|
||||
}
|
||||
t.wall = t.wall&^nsecMask | uint64(nsec) // update nsec
|
||||
t.addSec(dsec)
|
||||
if t.wall&hasMonotonic != 0 {
|
||||
te := t.ext + int64(d)
|
||||
if d < 0 && te > t.ext || d > 0 && te < t.ext {
|
||||
// Monotonic clock reading now out of range; degrade to wall-only.
|
||||
t.stripMono()
|
||||
} else {
|
||||
t.ext = te
|
||||
}
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
// Sub returns the duration t-u. If the result exceeds the maximum (or minimum)
|
||||
// value that can be stored in a Duration, the maximum (or minimum) duration
|
||||
// will be returned.
|
||||
// To compute t-d for a duration d, use t.Add(-d).
|
||||
func (t Time) Sub(u Time) Duration {
|
||||
if t.wall&u.wall&hasMonotonic != 0 {
|
||||
te := t.ext
|
||||
ue := u.ext
|
||||
d := Duration(te - ue)
|
||||
if d < 0 && te > ue {
|
||||
return maxDuration // t - u is positive out of range
|
||||
}
|
||||
if d > 0 && te < ue {
|
||||
return minDuration // t - u is negative out of range
|
||||
}
|
||||
return d
|
||||
}
|
||||
d := Duration(t.sec()-u.sec())*Second + Duration(t.nsec()-u.nsec())
|
||||
// Check for overflow or underflow.
|
||||
switch {
|
||||
case u.Add(d).Equal(t):
|
||||
return d // d is correct
|
||||
case t.Before(u):
|
||||
return minDuration // t - u is negative out of range
|
||||
default:
|
||||
return maxDuration // t - u is positive out of range
|
||||
}
|
||||
}
|
||||
|
||||
// Since returns the time elapsed since t.
|
||||
// It is shorthand for time.Now().Sub(t).
|
||||
func Since(t Time) Duration {
|
||||
var now Time
|
||||
if t.wall&hasMonotonic != 0 {
|
||||
// Common case optimization: if t has monotonic time, then Sub will use only it.
|
||||
now = Time{hasMonotonic, runtimeNano() - startNano, nil}
|
||||
} else {
|
||||
now = Now()
|
||||
}
|
||||
return now.Sub(t)
|
||||
}
|
||||
|
||||
// Until returns the duration until t.
|
||||
// It is shorthand for t.Sub(time.Now()).
|
||||
func Until(t Time) Duration {
|
||||
var now Time
|
||||
if t.wall&hasMonotonic != 0 {
|
||||
// Common case optimization: if t has monotonic time, then Sub will use only it.
|
||||
now = Time{hasMonotonic, runtimeNano() - startNano, nil}
|
||||
} else {
|
||||
now = Now()
|
||||
}
|
||||
return t.Sub(now)
|
||||
}
|
||||
|
||||
// Date returns the Time corresponding to
|
||||
//
|
||||
// yyyy-mm-dd hh:mm:ss + nsec nanoseconds
|
||||
@@ -717,20 +1042,3 @@ func norm(hi, lo, base int) (nhi, nlo int) {
|
||||
}
|
||||
return hi, lo
|
||||
}
|
||||
|
||||
// fmtInt formats v into the tail of buf.
|
||||
// It returns the index where the output begins.
|
||||
func fmtInt(buf []byte, v uint64) int {
|
||||
w := len(buf)
|
||||
if v == 0 {
|
||||
w--
|
||||
buf[w] = '0'
|
||||
} else {
|
||||
for v > 0 {
|
||||
w--
|
||||
buf[w] = byte(v%10) + '0'
|
||||
v /= 10
|
||||
}
|
||||
}
|
||||
return w
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user