v/vlib/time/time.v

421 lines
9.5 KiB
V
Raw Normal View History

2020-01-23 21:04:46 +01:00
// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
2019-06-23 04:21:30 +02:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
2019-06-22 20:20:28 +02:00
module time
2020-02-06 14:19:44 +01:00
#include <time.h>
2019-07-14 16:43:57 +02:00
const (
days_string = 'MonTueWedThuFriSatSun'
month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
months_string = 'JanFebMarAprMayJunJulAugSepOctNovDec'
2019-12-19 22:29:37 +01:00
// The unsigned zero year for internal calculations.
// Must be 1 mod 400, and times before it will not compute correctly,
// but otherwise can be changed at will.
absolute_zero_year = i64(-292277022399) // as i64
2019-12-19 22:29:37 +01:00
seconds_per_minute = 60
seconds_per_hour = 60 * seconds_per_minute
seconds_per_day = 24 * seconds_per_hour
seconds_per_week = 7 * seconds_per_day
2019-12-19 22:29:37 +01:00
days_per_400_years = 365 * 400 + 97
days_per_100_years = 365 * 100 + 24
days_per_4_years = 365 * 4 + 1
days_before = [
0,
31,
31 + 28,
31 + 28 + 31,
31 + 28 + 31 + 30,
31 + 28 + 31 + 30 + 31,
31 + 28 + 31 + 30 + 31 + 30,
31 + 28 + 31 + 30 + 31 + 30 + 31,
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
]
long_days = ['Monday', 'Tuesday', 'Wednesday', 'Thusday', 'Friday', 'Saturday', 'Sunday']
2019-07-14 16:43:57 +02:00
)
2019-10-25 21:04:25 +02:00
pub struct Time {
pub:
year int
month int
day int
hour int
minute int
second int
microsecond int
unix u64
2019-06-22 20:20:28 +02:00
}
pub enum FormatTime {
2019-12-19 22:29:37 +01:00
hhmm12
hhmm24
hhmmss12
hhmmss24
hhmmss24_milli
hhmmss24_micro
2019-12-19 22:29:37 +01:00
no_time
}
pub enum FormatDate {
2019-12-19 22:29:37 +01:00
ddmmyy
ddmmyyyy
mmddyy
mmddyyyy
mmmd
mmmdd
mmmddyyyy
no_date
yyyymmdd
}
pub enum FormatDelimiter {
2019-12-19 22:29:37 +01:00
dot
hyphen
slash
space
2020-05-08 20:23:26 +02:00
no_delimiter
}
2019-07-14 16:43:57 +02:00
2020-02-06 14:19:44 +01:00
pub struct C.timeval {
tv_sec u64
tv_usec u64
}
2019-12-19 22:29:37 +01:00
2020-05-18 21:38:06 +02:00
fn C.localtime(t &C.time_t) &C.tm
2019-09-15 18:07:40 +02:00
fn C.time(t &C.time_t) C.time_t
2020-06-10 11:14:55 +02:00
2020-02-06 14:19:44 +01:00
// now returns current local time.
pub fn now() Time {
$if macos {
return darwin_now()
}
$if windows {
return win_now()
}
$if solaris {
return solaris_now()
}
$if linux || android {
return linux_now()
}
// defaults to most common feature, the microsecond precision is not available
// in this API call
t := C.time(0)
2020-05-18 21:38:06 +02:00
now := C.localtime(&t)
return convert_ctime(now, 0)
}
2020-06-10 11:14:55 +02:00
// utc returns the current time in utc
pub fn utc() Time {
$if macos {
return darwin_utc()
}
$if windows {
return win_utc()
}
$if solaris {
return solaris_utc()
}
$if linux || android {
2020-06-10 11:14:55 +02:00
return linux_utc()
}
// defaults to most common feature, the microsecond precision is not available
// in this API call
t := C.time(0)
_ = C.time(&t)
return unix2(int(t), 0)
}
2020-02-06 14:19:44 +01:00
// smonth returns month name.
pub fn (t Time) smonth() string {
if t.month <= 0 || t.month > 12 {
return '---'
}
i := t.month - 1
return months_string[i * 3..(i + 1) * 3]
}
2020-02-06 14:19:44 +01:00
// new_time returns a time struct with calculated Unix time.
2019-06-28 16:04:14 +02:00
pub fn new_time(t Time) Time {
2019-12-31 17:11:47 +01:00
if t.unix != 0 {
return t
2019-06-22 20:20:28 +02:00
}
tt := C.tm{
2019-12-19 22:29:37 +01:00
tm_sec: t.second
tm_min: t.minute
tm_hour: t.hour
tm_mday: t.day
tm_mon: t.month - 1
tm_year: t.year - 1900
2019-06-22 20:20:28 +02:00
}
utime := u64(make_unix_time(tt))
return {
t |
unix: utime
}
}
// unix_time returns Unix time.
[inline]
pub fn (t Time) unix_time() int {
return int(t.unix)
}
// unix_time_milli returns Unix time with millisecond resolution.
[inline]
pub fn (t Time) unix_time_milli() u64 {
return t.unix * 1000 + u64(t.microsecond / 1000)
}
// add_seconds returns a new time struct with an added number of seconds.
pub fn (t Time) add_seconds(seconds int) Time {
2020-02-06 14:19:44 +01:00
// TODO Add(d time.Duration)
return unix(int(t.unix + u64(seconds)))
}
2020-02-06 14:19:44 +01:00
// add_days returns a new time struct with an added number of days.
2019-11-11 15:18:32 +01:00
pub fn (t Time) add_days(days int) Time {
return unix(int(t.unix + u64(i64(days) * 3600 * 24)))
2019-11-11 15:18:32 +01:00
}
2020-02-06 14:19:44 +01:00
// since returns a number of seconds elapsed since a given time.
fn since(t Time) int {
2020-02-06 14:19:44 +01:00
// TODO Use time.Duration instead of seconds
return 0
}
2020-02-06 14:19:44 +01:00
// relative returns a string representation of difference between time
// and current time.
pub fn (t Time) relative() string {
znow := now()
secs := znow.unix - t.unix
if secs <= 30 {
// right now or in the future
// TODO handle time in the future
return 'now'
}
if secs < 60 {
return '1m'
}
if secs < 3600 {
m := secs / 60
2020-06-12 15:28:24 +02:00
if m == 1 {
return '1 minute ago'
}
return '$m minutes ago'
}
if secs < 3600 * 24 {
h := secs / 3600
2020-06-12 15:28:24 +02:00
if h == 1 {
return '1 hour ago'
}
return '$h hours ago'
}
if secs < 3600 * 24 * 5 {
d := secs / 3600 / 24
2020-06-12 15:28:24 +02:00
if d == 1 {
return '1 day ago'
}
return '$d days ago'
}
if secs > 3600 * 24 * 10000 {
return ''
}
return t.md()
}
pub fn (t Time) relative_short() string {
znow := now()
secs := znow.unix - t.unix
if secs <= 30 {
// right now or in the future
// TODO handle time in the future
return 'now'
}
if secs < 60 {
return '1m'
2019-06-22 20:20:28 +02:00
}
if secs < 3600 {
return '${secs / 60}m'
2019-06-22 20:20:28 +02:00
}
if secs < 3600 * 24 {
return '${secs / 3600}h'
2019-06-22 20:20:28 +02:00
}
if secs < 3600 * 24 * 5 {
return '${secs / 3600 / 24}d'
}
if secs > 3600 * 24 * 10000 {
return ''
}
return t.md()
}
2020-02-06 14:19:44 +01:00
// day_of_week returns the current day of a given year, month, and day,
// as an integer.
pub fn day_of_week(y int, m int, d int) int {
2019-08-30 00:05:58 +02:00
// Sakomotho's algorithm is explained here:
// https://stackoverflow.com/a/6385934
t := [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4]
2019-08-30 00:05:58 +02:00
mut sy := y
if m < 3 {
sy = sy - 1
}
2019-12-19 22:29:37 +01:00
return (sy + sy / 4 - sy / 100 + sy / 400 + t[m - 1] + d - 1) % 7 + 1
}
2020-02-06 14:19:44 +01:00
// day_of_week returns the current day as an integer.
pub fn (t Time) day_of_week() int {
return day_of_week(t.year, t.month, t.day)
}
2020-02-06 14:19:44 +01:00
// weekday_str returns the current day as a string.
pub fn (t Time) weekday_str() string {
i := t.day_of_week() - 1
return days_string[i * 3..(i + 1) * 3]
2019-06-23 21:18:24 +02:00
}
2019-06-28 16:04:14 +02:00
2020-08-01 16:36:09 +02:00
// weekday_str returns the current day as a string.
pub fn (t Time) long_weekday_str() string {
i := t.day_of_week() - 1
return long_days[i]
}
2020-02-06 14:19:44 +01:00
// ticks returns a number of milliseconds elapsed since system start.
pub fn ticks() i64 {
$if windows {
2019-06-28 16:04:14 +02:00
return C.GetTickCount()
2019-12-19 22:29:37 +01:00
} $else {
ts := C.timeval{}
2019-12-19 22:29:37 +01:00
C.gettimeofday(&ts, 0)
return i64(ts.tv_sec * u64(1000) + (ts.tv_usec / u64(1000)))
}
2020-02-06 14:19:44 +01:00
// t := i64(C.mach_absolute_time())
// # Nanoseconds elapsedNano = AbsoluteToNanoseconds( *(AbsoluteTime *) &t );
// # return (double)(* (uint64_t *) &elapsedNano) / 1000000;
2019-06-28 16:04:14 +02:00
}
2020-02-06 14:19:44 +01:00
// sleep makes the calling thread sleep for a given number of seconds.
2019-06-28 16:04:14 +02:00
pub fn sleep(seconds int) {
$if windows {
2019-11-16 00:30:50 +01:00
C.Sleep(seconds * 1000)
2019-12-19 22:29:37 +01:00
} $else {
2019-06-28 16:04:14 +02:00
C.sleep(seconds)
}
2019-06-28 16:04:14 +02:00
}
2020-02-06 14:19:44 +01:00
// sleep_ms makes the calling thread sleep for a given number of milliseconds.
pub fn sleep_ms(milliseconds int) {
2019-12-19 22:29:37 +01:00
$if windows {
C.Sleep(milliseconds)
2019-12-19 22:29:37 +01:00
} $else {
C.usleep(milliseconds * 1000)
2019-12-19 22:29:37 +01:00
}
2019-06-28 16:04:14 +02:00
}
2020-02-06 14:19:44 +01:00
// usleep makes the calling thread sleep for a given number of microseconds.
pub fn usleep(microseconds int) {
$if windows {
milliseconds := microseconds / 1000
C.Sleep(milliseconds)
2019-12-19 22:29:37 +01:00
} $else {
C.usleep(microseconds)
}
2019-06-28 16:04:14 +02:00
}
2019-07-03 18:55:07 +02:00
2020-02-06 14:19:44 +01:00
// is_leap_year checks if a given a year is a leap year.
2019-07-03 18:55:07 +02:00
pub fn is_leap_year(year int) bool {
2019-12-19 22:29:37 +01:00
return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0)
2019-07-14 16:43:57 +02:00
}
2020-02-06 14:19:44 +01:00
// days_in_month returns a number of days in a given month.
pub fn days_in_month(month int, year int) ?int {
2019-07-14 16:43:57 +02:00
if month > 12 || month < 1 {
return error('Invalid month: $month')
}
2019-12-19 22:29:37 +01:00
extra := if month == 2 && is_leap_year(year) { 1 } else { 0 }
res := month_days[month - 1] + extra
return res
2019-07-14 16:43:57 +02:00
}
2020-02-06 14:19:44 +01:00
// str returns time in the same format as `parse` expects ("YYYY-MM-DD HH:MM:SS").
2020-01-20 15:06:15 +01:00
pub fn (t Time) str() string {
2020-02-06 14:19:44 +01:00
// TODO Define common default format for
// `str` and `parse` and use it in both ways
2020-01-20 15:06:15 +01:00
return t.format_ss()
}
2020-12-11 06:54:23 +01:00
// Time subtract using eperator overloading
pub fn (lhs Time) -(rhs Time) Duration {
lhs_micro := lhs.unix * 1000 * 1000 + u64(lhs.microsecond)
rhs_micro := rhs.unix * 1000 * 1000 + u64(rhs.microsecond)
return (i64(lhs_micro) - i64(rhs_micro)) * microsecond
}
fn convert_ctime(t C.tm, microsecond int) Time {
return Time{
year: t.tm_year + 1900
month: t.tm_mon + 1
day: t.tm_mday
hour: t.tm_hour
minute: t.tm_min
second: t.tm_sec
microsecond: microsecond
unix: u64(make_unix_time(t))
}
}
// A lot of these are taken from the Go library
pub type Duration = i64
pub const (
nanosecond = Duration(1)
microsecond = Duration(1000) * nanosecond
millisecond = Duration(1000) * microsecond
second = Duration(1000) * millisecond
minute = Duration(60) * second
hour = Duration(60) * minute
infinite = Duration(-1)
)
// nanoseconds returns the duration as an integer number of nanoseconds.
pub fn (d Duration) nanoseconds() i64 {
return i64(d)
}
// microseconds returns the duration as an integer number of microseconds.
pub fn (d Duration) microseconds() i64 {
return i64(d) / 1000
}
// milliseconds returns the duration as an integer number of milliseconds.
pub fn (d Duration) milliseconds() i64 {
return i64(d) / 1000000
}
// The following functions return floating point numbers because it's common to
// consider all of them in sub-one intervals
// seconds returns the duration as a floating point number of seconds.
pub fn (d Duration) seconds() f64 {
sec := d / second
nsec := d % second
return f64(sec) + f64(nsec) / 1e9
}
// minutes returns the duration as a floating point number of minutes.
pub fn (d Duration) minutes() f64 {
min := d / minute
nsec := d % minute
return f64(min) + f64(nsec) / (60 * 1e9)
}
// hours returns the duration as a floating point number of hours.
pub fn (d Duration) hours() f64 {
hr := d / hour
nsec := d % hour
return f64(hr) + f64(nsec) / (60 * 60 * 1e9)
}