mirror of
https://github.com/jimeh/go-tyme.git
synced 2026-02-19 01:46:41 +00:00
70 lines
2.0 KiB
Go
70 lines
2.0 KiB
Go
// Package ts provides wrapper types around time.Time, with support for
|
|
// JSON/YAML marshaling to/from numeric Unix timestamps of various precisions.
|
|
//
|
|
// Unmarshaling supports both numeric and string values. Marshaling always
|
|
// produces a integer value.
|
|
package ts
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/jimeh/go-tyme/dur"
|
|
)
|
|
|
|
// Timestamp is a type constraint that matches against time.Time, Second,
|
|
// Millisecond, Microsecond, and Nanosecond.
|
|
type Timestamp interface {
|
|
time.Time | Second | Millisecond | Microsecond | Nanosecond
|
|
}
|
|
|
|
// Duration is a type constraint that matches against time.Duration and
|
|
// dur.Duration.
|
|
type Duration interface {
|
|
time.Duration | dur.Duration
|
|
}
|
|
|
|
// Add returns a new Timestamp with given Duration added to it, using
|
|
// time.Time.Add.
|
|
func Add[T Timestamp, D Duration](ts T, d D) T {
|
|
var t time.Time
|
|
t = time.Time(ts)
|
|
t = t.Add(time.Duration(d))
|
|
|
|
return T(t)
|
|
}
|
|
|
|
// Sub returns the dur.Duration between two Timestamps, using time.Time.Sub.
|
|
func Sub[T, U Timestamp](t T, u U) dur.Duration {
|
|
return dur.Duration(time.Time(t).Sub(time.Time(u)))
|
|
}
|
|
|
|
// After reports whether the Timestamp instant t is after u, using
|
|
// time.Time.After.
|
|
func After[T, U Timestamp](t T, u U) bool {
|
|
return time.Time(t).After(time.Time(u))
|
|
}
|
|
|
|
// Before reports whether the Timestamp instant t is before u, using
|
|
// time.Time.Before.
|
|
func Before[T, U Timestamp](t T, u U) bool {
|
|
return time.Time(t).Before(time.Time(u))
|
|
}
|
|
|
|
// Equal reports whether t and u represent the same Timestamp instant, using
|
|
// time.Time.Equal.
|
|
func Equal[T, U Timestamp](t T, u U) bool {
|
|
return time.Time(t).Equal(time.Time(u))
|
|
}
|
|
|
|
// Round returns the result of rounding t to the nearest multiple of d, using
|
|
// time.Time.Round.
|
|
func Round[T Timestamp, D Duration](t T, d D) T {
|
|
return T(time.Time(t).Round(time.Duration(d)))
|
|
}
|
|
|
|
// Truncate returns the result of trucating t down to the nearest multiple of d,
|
|
// using time.Time.Truncate.
|
|
func Truncate[T Timestamp, D Duration](t T, d D) T {
|
|
return T(time.Time(t).Truncate(time.Duration(d)))
|
|
}
|