package core:time

Source

Benchmark_Error :: enum int {
	Okay             = 0, 
	Allocation_Error, 
}

Benchmark_Options :: struct {
	setup:                proc(options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error),
	bench:                proc(options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error),
	teardown:             proc(options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error),
	rounds:               int,
	bytes:                int,
	input:                []u8,
	count:                int,
	processed:            int,
	output:               []u8,
	// Unused for hash benchmarks
	hash:                 u128,
	// 		Performance
	duration:             Duration,
	rounds_per_second:    f64,
	megabytes_per_second: f64,
}

Duration :: distinct i64

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

Stopwatch :: struct {
	running:       bool,
	_start_time:   Tick,
	_accumulation: Duration,
}

Tick :: struct {
	_nsec: i64,
}

Time :: struct {
	_nsec: i64,
}

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

ABSOLUTE_TO_INTERNAL :: i64(-9223371966579724800)

ABSOLUTE_TO_UNIX: i64 : -UNIX_TO_ABSOLUTE

ABSOLUTE_ZERO_YEAR :: i64(-292277022399)

DAYS_PER_100_YEARS :: 365 * 100 + 24

DAYS_PER_400_YEARS :: 365 * 400 + 97

DAYS_PER_4_YEARS :: 365 * 4 + 1

Hour: Duration : 60 * Minute

INTERNAL_TO_ABSOLUTE: i64 : -ABSOLUTE_TO_INTERNAL

INTERNAL_TO_UNIX: i64 : -UNIX_TO_INTERNAL

INTERNAL_TO_WALL: i64 : -WALL_TO_INTERNAL

IS_SUPPORTED :: _IS_SUPPORTED

MAX_DURATION :: Duration(1 << 63 - 1)

MIN_DURATION :: Duration(-1 << 63)

Microsecond: Duration : 1000 * Nanosecond

Millisecond: Duration : 1000 * Microsecond

Minute: Duration : 60 * Second

Nanosecond :: Duration(1)

SECONDS_PER_DAY :: 24 * SECONDS_PER_HOUR

SECONDS_PER_HOUR :: 60 * SECONDS_PER_MINUTE

SECONDS_PER_MINUTE :: 60

SECONDS_PER_WEEK :: 7 * SECONDS_PER_DAY

Second: Duration : 1000 * Millisecond

UNIX_TO_ABSOLUTE: i64 : UNIX_TO_INTERNAL + INTERNAL_TO_ABSOLUTE

UNIX_TO_INTERNAL :: i64((1969 * 365 + 1969 / 4 - 1969 / 100 + 1969 / 400) * SECONDS_PER_DAY)

WALL_TO_INTERNAL :: i64((1884 * 365 + 1884 / 4 - 1884 / 100 + 1884 / 400) * SECONDS_PER_DAY)

days_before: [13]i32 = …

SCOPED_TICK_DURATION :: proc "contextless" (d: ^Duration) -> Tick {…}

accurate_sleep :: proc "contextless" (d: Duration) {…}

benchmark :: proc(options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error) {…}

clock_from_duration :: proc "contextless" (d: Duration) -> (hour, min, sec: int) {…}

clock_from_seconds :: proc "contextless" (nsec: u64) -> (hour, min, sec: int) {…}

clock_from_stopwatch :: proc "contextless" (s: Stopwatch) -> (hour, min, sec: int) {…}

clock_from_time :: proc "contextless" (t: Time) -> (hour, min, sec: int) {…}

components_to_time :: proc "contextless" (
	#any_int year, #any_int month, #any_int day, #any_int hour, #any_int minute, #any_int second: i64, 
	#any_int nsec:                          i64 = i64(0), 
) -> (t: Time, ok: bool) {…}

compound_to_time :: proc "contextless" (datetime: datetime.DateTime) -> (t: Time, ok: bool) {…}

date :: proc "contextless" (t: Time) -> (year: int, month: Month, day: int) {…}

day :: proc "contextless" (t: Time) -> (day: int) {…}

diff :: proc "contextless" (start, end: Time) -> Duration {…}

duration_hours :: proc "contextless" (d: Duration) -> f64 {…}

duration_microseconds :: proc "contextless" (d: Duration) -> f64 {…}

duration_milliseconds :: proc "contextless" (d: Duration) -> f64 {…}

duration_minutes :: proc "contextless" (d: Duration) -> f64 {…}

duration_nanoseconds :: proc "contextless" (d: Duration) -> i64 {…}

duration_round :: proc "contextless" (d, m: Duration) -> Duration {…}

duration_seconds :: proc "contextless" (d: Duration) -> f64 {…}

duration_truncate :: proc "contextless" (d, m: Duration) -> Duration {…}

has_invariant_tsc :: proc "contextless" () -> bool {…}

is_leap_year :: proc "contextless" (year: int) -> (leap: bool) {…}

month :: proc "contextless" (t: Time) -> (month: Month) {…}

now :: proc "contextless" () -> Time {…}

read_cycle_counter :: proc "contextless" () -> u64 {…}

rfc3339_to_components :: proc(rfc_datetime: string) -> (res: datetime.DateTime, utc_offset: int, is_leap: bool, consumed: int) {…}

rfc3339_to_time_and_offset :: proc(rfc_datetime: string, is_leap: ^bool = nil) -> (res: Time, utc_offset: int, consumed: int) {…}

rfc3339_to_time_utc :: proc(rfc_datetime: string, is_leap: ^bool = nil) -> (res: Time, consumed: int) {…}

since :: proc "contextless" (start: Time) -> Duration {…}

sleep :: proc "contextless" (d: Duration) {…}

stopwatch_duration :: proc "contextless" (stopwatch: Stopwatch) -> Duration {…}

stopwatch_reset :: proc "contextless" (stopwatch: ^Stopwatch) {…}

stopwatch_start :: proc "contextless" (stopwatch: ^Stopwatch) {…}

stopwatch_stop :: proc "contextless" (stopwatch: ^Stopwatch) {…}

tick_diff :: proc "contextless" (start, end: Tick) -> Duration {…}

tick_lap_time :: proc "contextless" (prev: ^Tick) -> Duration {…}

tick_now :: proc "contextless" () -> Tick {…}

tick_since :: proc "contextless" (start: Tick) -> Duration {…}

time_add :: proc "contextless" (t: Time, d: Duration) -> Time {…}

time_to_unix :: proc "contextless" (t: Time) -> i64 {…}

time_to_unix_nano :: proc "contextless" (t: Time) -> i64 {…}

to_unix_nanoseconds :: time_to_unix_nano

to_unix_seconds :: time_to_unix

tsc_frequency :: proc "contextless" (fallback_sleep: Duration = 2 * Second) -> (u64, bool) {…}

unix :: proc "contextless" (sec: i64, nsec: i64) -> Time {…}

weekday :: proc "contextless" (t: Time) -> (weekday: Weekday) {…}

year :: proc "contextless" (t: Time) -> (year: int) {…}

clock :: proc{
	clock_from_time,
	clock_from_duration,
	clock_from_stopwatch,
}

datetime_to_time :: proc{
	components_to_time,
	compound_to_time,
}