package core:time/datetime

Source

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

DateTime :: struct {
	using date: Date,
	using time: Time,
}

Delta :: struct {
	days:    i64,
	// These are all i64 because we can also use it to add a number of seconds or nanos to a moment,
	seconds: i64,
	// that are then normalized within their respective ranges.
	nanos:   i64,
}

Error :: enum int {
	None, 
	Invalid_Year, 
	Invalid_Month, 
	Invalid_Day, 
	Invalid_Hour, 
	Invalid_Minute, 
	Invalid_Second, 
	Invalid_Nano, 
	Invalid_Ordinal, 
	Invalid_Delta, 
}

Month :: enum i8 {
	January   = 1, 
	February, 
	March, 
	April, 
	May, 
	June, 
	July, 
	August, 
	September, 
	October, 
	November, 
	December, 
}

Ordinal :: i64

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

Weekday :: enum i8 {
	Sunday    = 0, 
	Monday, 
	Tuesday, 
	Wednesday, 
	Thursday, 
	Friday, 
	Saturday, 
}

EPOCH: i64 : Ordinal(1)

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

MAX_ORD: i64 : Ordinal(9_223_372_036_854_774_869)

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

MIN_ORD: i64 : Ordinal(-9_223_372_036_854_775_234)

add_days_to_date :: proc "contextless" (a: Date, days: i64) -> (date: Date, err: Error) {…}

add_delta_to_date :: proc "contextless" (a: Date, delta: Delta) -> (date: Date, err: Error) {…}

add_delta_to_datetime :: proc "contextless" (a: DateTime, delta: Delta) -> (datetime: DateTime, err: Error) {…}

adjusted_remainder :: proc "contextless" (x, b: i64) -> (res: i64) {…}

biggest :: proc "contextless" (k: i64, cond: proc "contextless" (n: i64) -> bool) -> (d: i64) {…}

components_to_date :: proc "contextless" (#any_int year, #any_int month, #any_int day: i64) -> (date: Date, err: Error) {…}

components_to_datetime :: proc "contextless" (
	#any_int year, #any_int month, #any_int day, #any_int hour, #any_int minute, #any_int second: i64, 
	#any_int nanos:                         i64 = i64(0), 
) -> (datetime: DateTime, err: Error) {…}

components_to_ordinal :: proc "contextless" (#any_int year, #any_int month, #any_int day: i64) -> (ordinal: i64, err: Error) {…}

components_to_time :: proc "contextless" (#any_int hour, #any_int minute, #any_int second: i64, #any_int nanos: i64 = i64(0)) -> (time: Time, err: Error) {…}

date_to_ordinal :: proc "contextless" (date: Date) -> (ordinal: i64, err: Error) {…}

day_number :: proc "contextless" (date: Date) -> (day_number: i64, err: Error) {…}

day_of_week :: proc "contextless" (ordinal: i64) -> (day: Weekday) {…}

days_remaining :: proc "contextless" (date: Date) -> (days_remaining: i64, err: Error) {…}

divmod :: proc "contextless" (x, y: $T, loc := #caller_location) -> (a: $T, r: $T) {…}

floor_div :: proc "contextless" (x, y: $T) -> (res: $T) {…}

gcd :: proc "contextless" (x, y: i64) -> (res: i64) {…}

interval_mod :: proc "contextless" (x, a, b: i64) -> (res: i64) {…}

is_leap_year :: proc "contextless" (#any_int year: i64) -> (leap: bool) {…}

last_day_of_month :: proc "contextless" (#any_int year: i64, #any_int month: i8) -> (day: i64, err: Error) {…}

lcm :: proc "contextless" (x, y: i64) -> (res: i64) {…}

new_year :: proc "contextless" (#any_int year: i64) -> (new_year: Date, err: Error) {…}

normalize_delta :: proc "contextless" (delta: Delta) -> (normalized: Delta, err: Error) {…}

ordinal_to_date :: proc "contextless" (ordinal: i64) -> (date: Date, err: Error) {…}

ordinal_to_datetime :: proc "contextless" (ordinal: i64) -> (datetime: DateTime, err: Error) {…}

product :: proc "contextless" (i: i64, f: proc "contextless" (n: i64) -> i64, cond: proc "contextless" (n: i64) -> bool) -> (res: i64) {…}

sign :: proc "contextless" (v: i64) -> (res: i64) {…}

smallest :: proc "contextless" (k: i64, cond: proc "contextless" (n: i64) -> bool) -> (d: i64) {…}

subtract_dates :: proc "contextless" (a, b: Date) -> (delta: Delta, err: Error) {…}

subtract_datetimes :: proc "contextless" (a, b: DateTime) -> (delta: Delta, err: Error) {…}

subtract_deltas :: proc "contextless" (a, b: Delta) -> (delta: Delta, err: Error) {…}

sum :: proc "contextless" (i: i64, f: proc "contextless" (n: i64) -> i64, cond: proc "contextless" (n: i64) -> bool) -> (res: i64) {…}

unsafe_date_to_ordinal :: proc "contextless" (date: Date) -> (ordinal: i64) {…}

unsafe_ordinal_to_date :: proc "contextless" (ordinal: i64) -> (date: Date) {…}

unsafe_ordinal_to_year :: proc "contextless" (ordinal: i64) -> (year: i64, day_ordinal: i64) {…}

validate_date :: proc "contextless" (date: Date) -> (err: Error) {…}

validate_datetime :: proc "contextless" (datetime: DateTime) -> (err: Error) {…}

validate_hour_minute_second :: proc "contextless" (#any_int hour, #any_int minute, #any_int second, #any_int nano: i64) -> (err: Error) {…}

validate_ordinal :: proc "contextless" (ordinal: i64) -> (err: Error) {…}

validate_time :: proc "contextless" (time: Time) -> (err: Error) {…}

validate_year_month_day :: proc "contextless" (#any_int year, #any_int month, #any_int day: i64) -> (err: Error) {…}

year_end :: proc "contextless" (#any_int year: i64) -> (year_end: Date, err: Error) {…}

year_range :: proc(#any_int year: i64, allocator := context.allocator) -> (range: []Date) {…}

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

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

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