core/time/datetime

datetime

Types

Date :: struct {
	year:  i64,
	month: i8,
	day:   i8,
}

Source

A type representing a date.

The minimum and maximum values for a year can be found in MIN_DATE and MAX_DATE constants. The month field can range from 1 to 12, and the day ranges from 1 to however many days there are in the specified month.

DateTime :: struct {
	date: Date,
	time: Time,
	tz:   ^TZ_Region,
}

Source

A type representing datetime.

Delta :: struct {
	days:    i64,
	seconds: i64,
	nanos:   i64,
}

Source

A type representing a difference between two instances of datetime.

Note: All fields are i64 because we can also use it to add a number of seconds or nanos to a moment, that are then normalized within their respective ranges.

Error :: enum int {
	None            = 0,
	Invalid_Year    = 1,
	Invalid_Month   = 2,
	Invalid_Day     = 3,
	Invalid_Hour    = 4,
	Invalid_Minute  = 5,
	Invalid_Second  = 6,
	Invalid_Nano    = 7,
	Invalid_Ordinal = 8,
	Invalid_Delta   = 9,
}

Source

Possible errors returned by datetime functions.

Month :: enum i8 {
	January   = 1,
	February  = 2,
	March     = 3,
	April     = 4,
	May       = 5,
	June      = 6,
	July      = 7,
	August    = 8,
	September = 9,
	October   = 10,
	November  = 11,
	December  = 12,
}

Source

Type representing one of the months.

Ordinal :: i64Source

Type representing a mononotic day number corresponding to a date.

Ordinal 1 = Midnight Monday, January 1, 1 A.D. (Gregorian)
	        |   Midnight Monday, January 3, 1 A.D. (Julian)

Every other ordinal counts days forwards, starting from the above date.

TZ_Date_Kind :: enum int {
	No_Leap        = 0,
	Leap           = 1,
	Month_Week_Day = 2,
}

Source

TZ_RRule :: struct {
	has_dst:    bool,
	std_name:   string,
	std_offset: i64,
	std_date:   TZ_Transition_Date,
	dst_name:   string,
	dst_offset: i64,
	dst_date:   TZ_Transition_Date,
}

Source

TZ_Record :: struct {
	time:       i64,
	utc_offset: i64,
	shortname:  string,
	dst:        bool,
}

Source

TZ_Region :: struct {
	name:       string,
	records:    []TZ_Record,
	shortnames: []string,
	rrule:      TZ_RRule,
}

Source

TZ_Transition_Date :: struct {
	type:  TZ_Date_Kind,
	month: u8,
	week:  u8,
	day:   u16,
	time:  i64,
}

Source

Time :: struct {
	hour:   i8,
	minute: i8,
	second: i8,
	nano:   i32,
}

Source

A type representing a time within a single day within a nanosecond precision.

Weekday :: enum i8 {
	Sunday    = 0,
	Monday    = 1,
	Tuesday   = 2,
	Wednesday = 3,
	Thursday  = 4,
	Friday    = 5,
	Saturday  = 6,
}

Source

Type representing one of the weekdays.

Constants

MAX_DATE :: Date = Date{year = 25_252_734_927_766_552, month = 12, day = 31}Source

Maximum valid value for date

The value is chosen such that a conversion date -> ordinal -> date is always safe.

MAX_ORD :: i64 = Ordinal( 9_223_372_036_854_774_869)Source

Maximum value for an ordinal

MIN_DATE :: Date = Date{year = -25_252_734_927_766_552, month = 1, day = 1}Source

Minimum valid value for date.

The value is chosen such that a conversion date -> ordinal -> date is always safe.

MIN_ORD :: i64 = Ordinal(-9_223_372_036_854_775_234)Source

Minimum value for an ordinal

Procedures

add_days_to_date :: proc(a: Date, days: i64) -> (date: Date, err: Error)Source

Add certain amount of days to a date.

This procedure adds the specified amount of days to a date and returns a new date. The new date would have happened the specified amount of days after the specified date.

add_delta_to_date :: proc(a: Date, delta: Delta) -> (date: Date, err: Error)Source

Add delta to a date.

This procedure adds a delta to a date, and returns a new date. The new date would have happened the time specified by delta after the specified date.

Note: The delta is assumed to be normalized. That is, if it contains seconds or milliseconds, regardless of the amount only the days will be added.

add_delta_to_datetime :: proc(a: DateTime, delta: Delta) -> (datetime: DateTime, err: Error)Source

Add delta to datetime.

This procedure adds a delta to a datetime, and returns a new datetime. The new datetime would have happened the time specified by delta after the specified datetime.

adjusted_remainder :: proc(x: i64, b: i64) -> (res: i64)Source

x mod [1..b]

biggest :: proc(k: i64, cond: proc(n: i64) -> (bool)) -> (d: i64)Source

components_to_date :: proc(any_int, any_int, day: i64) -> (date: Date, err: Error)Source

Obtain a date from date components.

This procedure converts date components, specified by a year, a month and a day, into a date object. If the provided date components don't represent a valid date, an error is returned.

components_to_datetime :: proc(
	any_int,
	any_int,
	any_int,
	any_int,
	any_int,
	second: i64,
	nanos:  _,
) -> (datetime: DateTime, err: Error)

Source

Obtain datetime from components.

This procedure converts date components and time components into a datetime object. If the provided date components or time components don't represent a valid datetime, an error is returned.

components_to_ordinal :: proc(any_int, any_int, day: i64) -> (ordinal: Ordinal, err: Error)Source

Obtain an ordinal from date components.

This procedure converts the specified date, provided by its individual components, into an ordinal. If the specified date is not a valid date, an error is returned.

components_to_time :: proc(any_int, any_int, second: i64, nanos) -> (time: Time, err: Error)Source

Obtain time from time components.

This procedure converts time components, specified by an hour, a minute, a second and nanoseconds, into a time object. If the provided time components don't represent a valid time, an error is returned.

date_to_ordinal :: proc(date: Date) -> (ordinal: Ordinal, err: Error)Source

Obtain an ordinal from a date.

This procedure converts the specified date into an ordinal. If the specified date is not a valid date, an error is returned.

day_number :: proc(date: Date) -> (day_number: i64, err: Error)Source

Obtain the day number in a year

This procedure returns the number of the day in a year, starting from 1. If the date is not a valid date, an error is returned.

day_of_week :: proc(ordinal: Ordinal) -> (day: Weekday)Source

Calculate the weekday from an ordinal.

This procedure takes the value of an ordinal and returns the day of week for that ordinal.

days_remaining :: proc(date: Date) -> (days_remaining: i64, err: Error)Source

Obtain the remaining number of days in a year.

This procedure returns the number of days between the specified date and December 31 of the same year. If the date is not a valid date, an error is returned.

divmod :: proc(x: T, y: T, loc = #caller_location) -> (a: T, r: T)Source

Caller has to ensure y != 0

floor_div :: proc(x: T, y: T) -> (res: T)Source

Divides and floors

gcd :: proc(x: i64, y: i64) -> (res: i64)Source

interval_mod :: proc(x: i64, a: i64, b: i64) -> (res: i64)Source

Half open: x mod [1..b]

is_leap_year :: proc(year: i64) -> (leap: bool)Source

Validation helpers Check if a year is a leap year.

last_day_of_month :: proc(year: i64, month: i8) -> (day: i8, err: Error)Source

Obtain the last day of a given month on a given year.

This procedure returns the amount of days in a specified month on a specified date. If the specified year or month is not valid, an error is returned.

lcm :: proc(x: i64, y: i64) -> (res: i64)Source

new_year :: proc(year: i64) -> (new_year: Date, err: Error)Source

Obtain the new year date of a given year.

This procedure returns the January 1st date of the specified year. If the year is not valid, an error is returned.

normalize_delta :: proc(delta: Delta) -> (normalized: Delta, err: Error)Source

Normalize the delta.

This procedure normalizes the delta in such a way that the number of seconds is between 0 and the number of seconds in the day and nanoseconds is between 0 and 10^9.

If the value for days overflows during this operation, an error is returned.

ordinal_to_date :: proc(ordinal: Ordinal) -> (date: Date, err: Error)Source

Obtain date using an Ordinal.

This provedure converts the specified ordinal into a date. If the ordinal is not a valid ordinal, an error is returned.

ordinal_to_datetime :: proc(ordinal: Ordinal) -> (datetime: DateTime, err: Error)Source

Obtain an datetime from an ordinal.

This procedure converts the value of an ordinal into a datetime. Since the ordinal only has the amount of days, the resulting time in the datetime object will always have the time equal to 00:00:00.000.

product :: proc(i: i64, f: proc(n: i64) -> (i64), cond: proc(n: i64) -> (bool)) -> (res: i64)Source

sign :: proc(v: i64) -> (res: i64)Source

smallest :: proc(k: i64, cond: proc(n: i64) -> (bool)) -> (d: i64)Source

subtract_dates :: proc(a: Date, b: Date) -> (delta: Delta, err: Error)Source

Calculate the difference between two dates.

This procedure calculates the difference between two dates a - b, and returns a delta between the two dates in days. If either a or b is not a valid date, an error is returned.

subtract_datetimes :: proc(a: DateTime, b: DateTime) -> (delta: Delta, err: Error)Source

Calculate the difference between two datetimes.

This procedure calculates the difference between two datetimes, a - b, and returns a delta between the two dates. The difference is returned in all three fields of the Delta struct: the difference in days, the difference in seconds and the difference in nanoseconds.

If either a or b is not a valid datetime, an error is returned.

subtract_deltas :: proc(a: Delta, b: Delta) -> (delta: Delta, err: Error)Source

Calculate a difference between two deltas.

sum :: proc(i: i64, f: proc(n: i64) -> (i64), cond: proc(n: i64) -> (bool)) -> (res: i64)Source

unsafe_date_to_ordinal :: proc(date: Date) -> (ordinal: Ordinal)Source

The following procedures don't check whether their inputs are in a valid range. They're still exported for those who know their inputs have been validated. Obtain an ordinal from a date.

This procedure converts a date into an ordinal. If the date is not a valid date, the result is unspecified.

unsafe_ordinal_to_date :: proc(ordinal: Ordinal) -> (date: Date)Source

Obtain a date from an ordinal.

This procedure converts an ordinal into a date. If the ordinal is outside of its valid range, the result is unspecified.

unsafe_ordinal_to_year :: proc(ordinal: Ordinal) -> (year: i64, day_ordinal: i64)Source

Obtain a year and a day of the year from an ordinal.

This procedure returns the year and the day of the year of a given ordinal. Of the ordinal is outside of its valid range, the result is unspecified.

validate_date :: proc(date: Date) -> (err: Error)Source

Check for errors in date formation.

This procedure validates all fields of a date, and if any of the fields is outside of allowed range, an error is returned.

validate_datetime :: proc(datetime: DateTime) -> (err: Error)Source

Check for errors in datetime formation.

This procedure checks whether all fields of date and time in the specified datetime are valid, and if not, an error is returned.

validate_hour_minute_second :: proc(any_int, any_int, any_int, nano: i64) -> (err: Error)Source

Check for errors in time formed by its components.

This procedure checks whether the time formed by its components is valid, and if not an error is returned.

validate_ordinal :: proc(ordinal: Ordinal) -> (err: Error)Source

Check for errors in Ordinal

This procedure checks if the ordinal is in a valid range for roundtrip conversions with the dates. If not, an error is returned.

validate_time :: proc(time: Time) -> (err: Error)Source

Check for errors in time formation

This procedure checks whether time has all fields in valid ranges, and if not an error is returned.

validate_year_month_day :: proc(any_int, any_int, day: i64) -> (err: Error)Source

Check for errors in date formation given date components.

This procedure checks whether a date formed by the specified year month and a day is a valid date. If not, an error is returned.

year_end :: proc(year: i64) -> (year_end: Date, err: Error)Source

Obtain the end year of a given date.

This procedure returns the December 31st date of the specified year. If the year is not valid, an error is returned.

year_range :: proc(year: i64, allocator: mem.Allocator = context.allocator) -> (range: []Date)Source

Obtain the range of dates for a given year.

This procedure returns dates, for every day of a given year in a slice.

Procedure Groups

add :: proc{add_days_to_date, add_delta_to_date, add_delta_to_datetime}Source

Add days to a date, delta to a date or delta to datetime.

sub :: proc{subtract_datetimes, subtract_dates, subtract_deltas}Source

Calculate a difference between two datetimes, dates or deltas.

validate :: proc{validate_date, validate_year_month_day, validate_ordinal, validate_hour_minute_second, validate_time, validate_datetime}

Source

Check for errors in date, time or datetime.

datetime

Types

Constants

Procedures

Procedure Groups

Find anything

Settings