Types
TimestampError = object of CatchableError
TimestampInvalidFormatError = object of TimestampError
TimestampOutOfRangeError = object of TimestampError
TimespanError = object of CatchableError
TimespanInvalidFormatError = object of TimespanError
Timespan = distinct int64
Timestamp = object self: int64
Consts
NANO_SECOND = 1'i64
MICRO_SECOND = 1000
MILLI_SECOND = 1000000
SECOND = 1000000000
MINUTE = 60000000000
HOUR = 3600000000000
DAY = 86400000000000
Procs
proc `==`(a, b: Timespan): bool {...}{.borrow.}
proc `<`(a, b: Timespan): bool {...}{.borrow.}
proc `<=`(a, b: Timespan): bool {...}{.borrow.}
proc `*`[T: SomeInteger](n: T; span: Timespan): Timespan {...}{.inline.}
proc `div`[T: SomeInteger](span: Timespan; n: T): Timespan {...}{.inline.}
proc `div`(a, b: Timespan): int64 {...}{.inline, raises: [], tags: [].}
proc `+`(a, b: Timespan): Timespan {...}{.inline, raises: [], tags: [].}
proc `-`(a, b: Timespan): Timespan {...}{.inline, raises: [], tags: [].}
proc systemRealTime(): Timestamp {...}{.raises: [TimestampError], tags: [].}
- create a timestamp with current system time
proc initTimestamp(): Timestamp {...}{.inline, raises: [TimestampError], tags: [].}
proc toDateTime(t: Timestamp): DateTime {...}{.raises: [], tags: [].}
- Convert Timestmap to DateTime
Funcs
func i64(span: Timespan): int64 {...}{.inline, raises: [], tags: [].}
- Convert to number of nano-second
func i64(stamp: Timestamp): int64 {...}{.raises: [], tags: [].}
- Convert to number of nano-second since epoch time in int64
func `==`(a, b: Timestamp): bool {...}{.raises: [], tags: [].}
func `<`(a, b: Timestamp): bool {...}{.raises: [], tags: [].}
func `<=`(a, b: Timestamp): bool {...}{.raises: [], tags: [].}
func max(a, b: Timestamp): Timestamp {...}{.raises: [], tags: [].}
func min(a, b: Timestamp): Timestamp {...}{.raises: [], tags: [].}
func initTimestamp(ns: int64): Timestamp {...}{.raises: [], tags: [].}
- create a timestamp with number of nano-second since epoch
func initTimestamp(year, month, day: int; hour = 0; minute = 0; second = 0; milli = 0; micro = 0; nano = 0): Timestamp {...}{.raises: [], tags: [].}
- create a timestamp with normal written units
func `+`(a: Timestamp; ns: Timespan): Timestamp {...}{.inline, raises: [], tags: [].}
func `-`(a: Timestamp; ns: Timespan): Timestamp {...}{.inline, raises: [], tags: [].}
func `-`(a, b: Timestamp): Timespan {...}{.raises: [], tags: [].}
func epoch(t: Timestamp): float {...}{.raises: [], tags: [].}
func daySinceEpoch(t: Timestamp): int64 {...}{.raises: [], tags: [].}
func nanoSecond(t: Timestamp): int {...}{.raises: [], tags: [].}
- Extract nano-second in zulu time, range from 0~999
func microSecond(t: Timestamp): int {...}{.raises: [], tags: [].}
- Extract micro-second in zulu time, range from 0~999
func milliSecond(t: Timestamp): int {...}{.raises: [], tags: [].}
- Extract milli-second in zulu time, range from 0~999
func second(t: Timestamp): int {...}{.raises: [], tags: [].}
- Extract minute in zulu time.
func minute(t: Timestamp): int {...}{.raises: [], tags: [].}
- Extract hour in zulu time
func hour(t: Timestamp): int {...}{.raises: [], tags: [].}
- Extract day in zulu time
func subSecond(t: Timestamp): int {...}{.raises: [], tags: [].}
- Number of nano-second since last whole second
func yearMonthDay(t: Timestamp): tuple[year: int, month: int, day: int] {...}{. raises: [], tags: [].}
- Convert Timestamp to calendar year month and day
func addMonth(a: Timestamp; m: int): Timestamp {...}{.raises: [], tags: [].}
- Add m month to a. m could be negative
func addYear(a: Timestamp; y: int): Timestamp {...}{.raises: [], tags: [].}
func add(a: Timestamp; year: int = 0; month: int = 0; day: int = 0; hour: int = 0; minute: int = 0; second: int = 0; millisecond: int = 0; microsecond: int = 0; nanosecond: int = 0): Timestamp {...}{.raises: [], tags: [].}
func zulu(t: Timestamp): string {...}{.raises: [ValueError], tags: [].}
- Convert timestamp to string with milli-second precision Use $ if you need full (nano-second) precision
func `$`(t: Timestamp): string {...}{.raises: [ValueError], tags: [].}
- Convert Timestamp to string
func parseZulu(s: string): Timestamp {...}{.raises: [TimestampInvalidFormatError, ValueError, TimestampOutOfRangeError], tags: [].}
-
The following format are supported.
2001-02-03T04:05:06Z 2001-02-03T04:05:06.1Z 2001-02-03T04:05:06.12Z 2001-02-03T04:05:06.123Z 2001-02-03T04:05:06.123456Z 2001-02-03T04:05:06.123456789Z
func inDay(t: Timespan): float {...}{.raises: [], tags: [].}
- Number of day since epoch time.
func inHour(t: Timespan): float {...}{.raises: [], tags: [].}
- Number of hour since epoch time.
func inMinute(t: Timespan): float {...}{.raises: [], tags: [].}
- Number of minute since epoch time.
func inSecond(t: Timespan): float {...}{.raises: [], tags: [].}
- Number of second since epoch time.
func inMilliSecond(t: Timespan): float {...}{.raises: [], tags: [].}
- Number of milli-second since epoch time.
func inMicroSecond(t: Timespan): float {...}{.raises: [], tags: [].}
- Number of micro-second since epoch time.
func inNanoSecond(t: Timespan): float {...}{.raises: [], tags: [].}
- Number of nano-second since epoch time.
func toTime(t: Timestamp): Time {...}{.raises: [], tags: [].}
- Convert Timestamp to Time
func toTimestamp(t: Time): Timestamp {...}{.raises: [], tags: [].}
- Convert Time to timestamp
func toTimestamp(t: DateTime): Timestamp {...}{.raises: [], tags: [].}
- Convert DateTime to Timestamp
func `$`(t: Timespan): string {...}{.raises: [], tags: [].}
func parseTimespan(s: string): Timespan {...}{.raises: [TimespanInvalidFormatError], tags: [].}