times

nimony/lib/std/times.nim

The std/times module provides basic support for working with time.

This is a minimal implementation for Nimony: it covers Unix-epoch based points in time with nanosecond resolution, simple durations, and a calendar breakdown in UTC, the process's local zone, or a Timezone of the application's own. For monotonic timestamps suitable for measuring durations, use std/monotimes.

type Month = HoleyEnum
func dollar`.Month(e: Month): string

type WeekDay = enum
  dMon = (0, "dMon")
  dTue = (1, "dTue")
  dWed = (2, "dWed")
  dThu = (3, "dThu")
  dFri = (4, "dFri")
  dSat = (5, "dSat")
  dSun = (6, "dSun")

func dollar`.WeekDay(e: WeekDay): string

type Time = object
  seconds: int64
  nanosecond: int32

type Duration = object
  seconds: int64
  nanosecond: int32

type ZonedTime = object
  time: Time
  offsetEast: int64
  isDst: bool

type Timezone = ref Timezone.Obj not nil

type Timezone.Obj = object
  name: string
  zonedTimeFromTimeImpl: proc (time: Time): ZonedTime {.closure.}
  zonedTimeFromAdjTimeImpl: proc (adjTime: Time): ZonedTime {.closure.}

type DateTime = object
  year: int64
  month: Month
  monthday: int32
  hour: int32
  minute: int32
  second: int32
  nanosecond: int32
  weekday: WeekDay
  yearday: int32
  offsetEast: int64
  isDst: bool
  timezone: ref Timezone.Obj

func initTime(seconds: int64; nanoseconds: int64): Time
Creates a new Time from a Unix timestamp.
func fromUnix(unix: int64): Time
Convert a Unix timestamp (seconds since 1970-01-01 UTC) to a Time.
func toUnix(t: Time): int64
Converts t to a Unix timestamp.
func seconds(t: Time): int64
func nanosecond(t: Time): int32
func initDuration(seconds: int64; nanoseconds: int64; milliseconds: int64; microseconds: int64; minutes: int64; hours: int64; days: int64; weeks: int64): Duration
Creates a new Duration.
func inSeconds(d: Duration): int64
func inMilliseconds(d: Duration): int64
func inMicroseconds(d: Duration): int64
func inNanoseconds(d: Duration): int64
func ==(a: Time; b: Time): bool
func <(a: Time; b: Time): bool
func <=(a: Time; b: Time): bool
func ==(a: Duration; b: Duration): bool
func <(a: Duration; b: Duration): bool
func <=(a: Duration; b: Duration): bool
func -(a: Time; b: Time): Duration
Returns the duration between two times.
func +(t: Time; d: Duration): Time
Adds a duration to a time.
func -(t: Time; d: Duration): Time
Subtracts a duration from a time.
proc getTime(): Time
Gets the current time as a Time with up to nanosecond resolution.
func isLeapYear(year: int64): bool
Returns true if year is a leap year in the proleptic Gregorian calendar.
func getDaysInMonth(month: Month; year: int64): int32
Get the number of days in month of year.
func toTime(dt: DateTime): Time
Converts a DateTime to the instant it names: its fields, less its offsetEast.
func offsetEast(dt: DateTime): int64
Seconds east of UTC, DST included: +12:00 is 43200, so local = utc + offsetEast, as in ISO 8601. Nim 2's utcOffset counts west; the different name keeps ported code from silently flipping sign.
func isDst(dt: DateTime): bool
Whether DST was in effect at this instant in dt's zone.
func timezone(dt: DateTime): ref Timezone.Obj
The zone the fields are expressed in; nil only for a default(DateTime).
proc newTimezone(name: string; zonedTimeFromTimeImpl: proc (time: Time): ZonedTime {.closure.}; zonedTimeFromAdjTimeImpl: proc (adjTime: Time): ZonedTime {.closure.}): ref Timezone.Obj not nil
Creates a zone from its name and its two conversions.
proc name(zone: ref Timezone.Obj not nil): string
proc zonedTimeFromTime(zone: ref Timezone.Obj not nil; time: Time): ZonedTime
The zone's offset and DST state at the instant time.
proc zonedTimeFromAdjTime(zone: ref Timezone.Obj not nil; adjTime: Time): ZonedTime
The instant named by a wall-clock reading (adjTime: the fields read as if they were UTC), with the offset that applied to it.
proc $(zone: ref Timezone.Obj not nil): string
proc utc(): ref Timezone.Obj not nil
The UTC zone, named Etc/UTC.
proc local(): ref Timezone.Obj not nil
The process's zone (TZ, else the system default), named LOCAL. A process that inherits UTC answers UTC.
proc inZone(time: Time; zone: ref Timezone.Obj not nil): DateTime
The DateTime for the instant time in zone, so toTime(inZone(t, zone)) == t.
proc inZone(dt: DateTime; zone: ref Timezone.Obj not nil): DateTime
The same instant, expressed in zone.
proc initDateTime(year: int64; month: Month; monthday: int32; hour: int32; minute: int32; second: int32; nanosecond: int32; zone: ref Timezone.Obj not nil): DateTime
Creates a DateTime from a wall-clock reading in zone.
proc utc(t: Time): DateTime
Converts a Time to a DateTime in UTC.
proc local(t: Time): DateTime
Converts a Time to a DateTime in the process's zone.
proc utc(dt: DateTime): DateTime
proc local(dt: DateTime): DateTime
proc now(): DateTime
Returns the current UTC date and time.
func $(dt: DateTime): string
Converts a DateTime to ISO-8601: YYYY-MM-DDTHH:MM:SS followed by Z in UTC (or with no zone) and ±HH:MM in any other zone.
func $(t: Time): string
A Time names an instant, so it renders in UTC, with Z.
func $(d: Duration): string
Formats a Duration as Ns M.N (seconds.nanoseconds).