From 351aae58f2c73749a12e2b19cbb447614a2ee3ff Mon Sep 17 00:00:00 2001 From: Laurent Bercot Date: Tue, 27 Sep 2022 08:49:04 +0000 Subject: Doc fixes: remove _t from skalibs types Signed-off-by: Laurent Bercot --- doc/libstddjb/tai.html | 122 ++++++++++++++++++++++++------------------------- 1 file changed, 61 insertions(+), 61 deletions(-) (limited to 'doc/libstddjb/tai.html') diff --git a/doc/libstddjb/tai.html b/doc/libstddjb/tai.html index 892cf45..dcdad11 100644 --- a/doc/libstddjb/tai.html +++ b/doc/libstddjb/tai.html @@ -91,8 +91,8 @@ borrow any code from it.

Data structures

- A tai_t structure holds an absolute date with a one-second -precision. A tain_t structure holds an absolute date with a + A tai structure holds an absolute date with a one-second +precision. A tain structure holds an absolute date with a maximum of one-nanosecond precision, as permitted by the underlying system call. If flag-usert is clear, the system clock will be read via @@ -101,12 +101,12 @@ system call, which has a one-microsecond precision; if it is set, the system clock will be read via the clock_gettime() system call, which has a one-nanosecond precision. In either case, a current -tain_t will be unable to be more precise than the underlying +tain will be unable to be more precise than the underlying implementation.

- A tai_t, as well as a tain_t, can also + A tai, as well as a tain, can also hold a (possibly negative) relative time, i.e. a difference of absolute dates. It is up to the programmer to make sure that a relative time is never interpreted as an absolute TAI64 date, and vice-versa. @@ -117,7 +117,7 @@ never interpreted as an absolute TAI64 date, and vice-versa.

Wallclock operations

- int tai_now (tai_t *t)
+ int tai_now (tai *t)
Writes the current time as a TAI value to *t, with a 1-second precision. The current time is based on the system clock. Make sure skalibs has been compiled with or without the @@ -129,10 +129,10 @@ it fails.

- int sysclock_get (tain_t *a)
+ int sysclock_get (tain *a)
Reads the current value of the system clock (as in CLOCK_REALTIME) into *a. Returns 1 if it succeeds or 0 (and sets errno) if it fails. -Note that despite being a tain_t, *a +Note that despite being a tain, *a does not contain a TAI value - it only contains an internal, Y2038-safe representation of the value of the system clock, which should be either TAI-10 or UTC. You should not use @@ -140,14 +140,14 @@ this function directly unless you know exactly what you are doing.

- int sysclock_set (tain_t const *a)
+ int sysclock_set (tain const *a)
Sets the system clock to *a, provided *a has the correct internal representation. You should not use this function directly unless you know exactly what you are doing.

- int tain_wallclock_read (tain_t *a)
+ int tain_wallclock_read (tain *a)
Reads the current time into *a, as a TAI64N value. Returns 1 if it succeeds or 0 (and sets errno) if it fails. Here a contains a valid TAI64N stamp, no matter what the @@ -156,7 +156,7 @@ on it.

- int tain_setnow (tain_t const *a)
+ int tain_setnow (tain const *a)
Sets the current time to *a. Returns 1 if it succeeds or 0 (and sets errno) if it fails. a must contain a valid TAI64N stamp; proper @@ -165,7 +165,7 @@ the right format for the system clock.

- int tain_now_set_wallclock (tain_t *a)
+ int tain_now_set_wallclock (tain *a)
Tells skalibs that future invocations of tain_now() (see below) should use a wall clock, i.e. the system time as returned by clock_gettime(CLOCK_REALTIME) or @@ -186,7 +186,7 @@ Otherwise, they will fail with errno set to ENOSYS.

- int tain_stopwatch_init (tain_t *a, clock_t cl, tain_t *offset)
+ int tain_stopwatch_init (tain *a, clock_t cl, tain *offset)
Initializes a stopwatch in *offset, using a clock named cl. Typically, cl is something like CLOCK_MONOTONIC, when it is defined by the system. The actual value of @@ -208,7 +208,7 @@ to zero.

- int tain_stopwatch_read (tain_t *a, clock_t cl, tain_t const *offset)
+ int tain_stopwatch_read (tain *a, clock_t cl, tain const *offset)
Gives the absolute time, as a TAI64N value, in *a. This absolute time is computed as a linear increase (as measured with the cl clock, which should be a monotonic clock such as @@ -220,7 +220,7 @@ The function returns 1 if it succeeds or 0 (and sets errno) if it fails.

- int tain_now_set_stopwatch (tain_t *a)
+ int tain_now_set_stopwatch (tain *a)
Tells skalibs that future invocations of tain_now() (see below) should use a stopwatch, i.e. the system time as returned by clock_gettime(CLOCK_MONOTONIC) or similar, @@ -240,7 +240,7 @@ is returned in *a.

All-purpose time reading

- int tain_now (tain_t *a)
+ int tain_now (tain *a)
Writes the current time, as a TAI value, to *a. This is the function you should use by default. It returns 1 if it succeeds or 0 (and sets errno) if it fails. @@ -279,8 +279,8 @@ use the STAMP global variable to store the current timestamp.) format to another; they do not make any assumption about the format of the time contained in those structures. For instance, for the tai_from_timeval function, if the struct timeval -contains an absolute UTC time, then the tai_t will also contain -the same UTC time. Despite being a tai_t, it may contain +contains an absolute UTC time, then the tai will also contain +the same UTC time. Despite being a tai, it may contain something else than TAI time.

@@ -290,32 +290,32 @@ system clock format to TAI, see the next section.

- int tai_from_time (tai_t *t, time_t u)
-int tai_relative_from_time (tai_t *t, time_t u)
+ int tai_from_time (tai *t, time_t u)
+int tai_relative_from_time (tai *t, time_t u)
Those functions convert an absolute (resp. relative) time in a time_t to an absolute (resp. relative) -time in a tai_t, with a 1-second precision. They return 1, +time in a tai, with a 1-second precision. They return 1, unless the time_t value is invalid (in which case they return 0).

- int time_from_tai (time_t *u, tai_t const *t)
-int time_from_tai_relative (time_t *u, tai_t const *t)
+ int time_from_tai (time_t *u, tai const *t)
+int time_from_tai_relative (time_t *u, tai const *t)
The inverse functions of the previous ones. Be aware that time_t is 32 bits on some systems and cannot store all values -of a tai_t (in which case the functions will return 0 EOVERFLOW). +of a tai (in which case the functions will return 0 EOVERFLOW).

- int tain_from_timeval (tain_t *a, struct timeval const *tv)
-int tain_relative_from_timeval (tain_t *a, struct timeval const *tv)
-int tain_from_timespec (tain_t *a, struct timespec const *ts)
-int tain_relative_from_timespec (tain_t *a, struct timespec const *ts)
-int timeval_from_tain (struct timeval *tv, tain_t const *a)
-int timeval_from_tain_relative (struct timeval *tv, tain_t const *a)
-int timespec_from_tain (struct timespec *ts, tain_t const *a)
-int timespec_from_tain_relative (struct timespec *ts, tain_t const *a)
-Same conversion operations, between tain_t and a + int tain_from_timeval (tain *a, struct timeval const *tv)
+int tain_relative_from_timeval (tain *a, struct timeval const *tv)
+int tain_from_timespec (tain *a, struct timespec const *ts)
+int tain_relative_from_timespec (tain *a, struct timespec const *ts)
+int timeval_from_tain (struct timeval *tv, tain const *a)
+int timeval_from_tain_relative (struct timeval *tv, tain const *a)
+int timespec_from_tain (struct timespec *ts, tain const *a)
+int timespec_from_tain_relative (struct timespec *ts, tain const *a)
+Same conversion operations, between tain and a struct timeval or struct timespec. The 1-microsecond (for struct timeval) or 1-nanosecond (for struct timespec) precision is preserved. @@ -326,8 +326,8 @@ precision is preserved.

Unlike the previous functions, the functions listed here will always operate on valid absolute timestamps. Only TAI64 time is -stored in tai_t structures, and only TAI64N time is stored in -tain_t structures. These functions will convert to/from TAI, +stored in tai structures, and only TAI64N time is stored in +tain structures. These functions will convert to/from TAI, from/to the machine system clock format, i.e. TAI-10 or UTC depending on whether skalibs was compiled with the --enable-tai-clock configure option). @@ -347,31 +347,31 @@ happen on systems with a 32 bit time_t), or other error codes.

- int tai_from_time_sysclock (tai_t *a, time_t t)
-int time_sysclock_from_tai (time_t *t, tai_t const *a)
-int tain_from_timeval_sysclock (tain_t *a, struct timeval const *tv)
-int timeval_sysclock_from_tain (struct timeval *tv, tain_t const *a)
-int tain_from_timespec_sysclock (tain_t *a, struct timespec const *ts)
-int timespec_sysclock_from_tain (struct timespec *ts, tain_t const *a) + int tai_from_time_sysclock (tai *a, time_t t)
+int time_sysclock_from_tai (time_t *t, tai const *a)
+int tain_from_timeval_sysclock (tain *a, struct timeval const *tv)
+int timeval_sysclock_from_tain (struct timeval *tv, tain const *a)
+int tain_from_timespec_sysclock (tain *a, struct timespec const *ts)
+int timespec_sysclock_from_tain (struct timespec *ts, tain const *a)

Conversions to/from basic types

- int tain_uint (tain_t *a, unsigned int c)
+ int tain_uint (tain *a, unsigned int c)
Stores a relative time of c seconds into a. Normally returns 1, but may return 0 EINVAL on pathological numbers.

- int tain_from_millisecs (tain_t *a, int ms)
-This function makes a tain_t representing a relative + int tain_from_millisecs (tain *a, int ms)
+This function makes a tain representing a relative time of ms milliseconds. ms must be non-negative. The function returns 1, unless ms is negative, in which case it returns 0 EINVAL.

- int tain_to_millisecs (tain_t const *a)
+ int taino_millisecs (tain const *a)
If *a contains a non-negative relative time that fits into a 31-bit integer number of milliseconds, the function returns that number. Else it returns -1 EINVAL. @@ -380,14 +380,14 @@ number. Else it returns -1 EINVAL.

Time computations

- int tai_add (tai_t *t, tai_t const *t1, tai_t const *t2)
+ int tai_add (tai *t, tai const *t1, tai const *t2)
Stores *t1 + *t2 into t. Of course, *t1 and *t2 must not both represent absolute times. The function normally returns 1, but will return 0 on bad inputs.

- int tai_sub (tai_t *t, tai_t const *t1, tai_t const *t2)
+ int tai_sub (tai *t, tai const *t1, tai const *t2)
Stores *t1 - *t2 into t. *t1 cannot be relative if *t2 is absolute. If they are both relative or both absolute, then *t is relative, else it's absolute. @@ -395,27 +395,27 @@ The function normally returns 1, but will return 0 on bad inputs.

- int tain_add (tain_t *a, tain_t const *a1, tain_t const *a2)
-int tain_sub (tain_t *a, tain_t const *a1, tain_t const *a2)
-Same thing with tain_t. + int tain_add (tain *a, tain const *a1, tain const *a2)
+int tain_sub (tain *a, tain const *a1, tain const *a2)
+Same thing with tain.

- int tain_addsec (tain_t *a, tain_t const *a1, int c)
+ int tain_addsec (tain *a, tain const *a1, int c)
Adds c seconds to *a1 and stores the result into a. c may be negative.

- void tain_half (tain_t *a, tain_t const *b)
+ void tain_half (tain *a, tain const *b)
Stores *b/2 into a. *b must be relative.

Comparing dates or durations

- int tai_less (tai_t const *t1, tai_t const *t2)
-int tain_less (tain_t const *t1, tain_t const *t2)
+ int tai_less (tai const *t1, tai const *t2)
+int tain_less (tain const *t1, tain const *t2)
Those functions return nonzero iff *t1 is lesser than *t2. *t1 and *t2 must be both relative, or both absolute.

@@ -423,7 +423,7 @@ Those functions return nonzero iff *t1 is lesser than *t2.

Packing and unpacking

- void tai_pack (char *s, tai_t const *t)
+ void tai_pack (char *s, tai const *t)
Marshals *t into the buffer s points to, which must be preallocated with at least TAI_PACK (8) characters. Afterwards, the buffer contains the @@ -432,7 +432,7 @@ representation of *t.

- void tai_unpack (char const *s, tai_t *t)
+ void tai_unpack (char const *s, tai *t)
Unmarshals the external TAI64 format label pointed to by s (at least TAI_PACK characters) and stores @@ -440,8 +440,8 @@ the result into t.

- void tain_pack (char *s, tain_t const *a)
-void tain_unpack (char const *s, tain_t *a)
+ void tain_pack (char *s, tain const *a)
+void tain_unpack (char const *s, tain *a)
Same thing with external TAI64N format, using TAIN_PACK (12) characters. @@ -450,7 +450,7 @@ using TAIN_PACK (12) characters.

Formatting and scanning

- unsigned int tain_fmt (char *s, tain_t const *a)
+ unsigned int tain_fmt (char *s, tain const *a)
Writes into s an ASCII representation of *a in external TAI64N format. s must point to a preallocated buffer of at least TAIN_PACK*2 (24) characters. The function returns the number of bytes that @@ -458,7 +458,7 @@ have been written to s (24).

- unsigned int tain_scan (char const *s, tain_t *a)
+ unsigned int tain_scan (char const *s, tain *a)
Reads 24 characters from s; if those characters are a valid ASCII representation of the external TAI64N format of some time value, this value is stored into a, and 24 is returned. Else 0 is returned. @@ -473,13 +473,13 @@ format of an absolute date.

- unsigned int timestamp_fmt (char *s, tain_t const *a)
+ unsigned int timestamp_fmt (char *s, tain const *a)
Writes a TAI64N timestamp representing the absolute date *a into the 25 characters pointed to by s. Returns 25.

- unsigned int timestamp_scan (char const *s, tain_t *a)
+ unsigned int timestamp_scan (char const *s, tain *a)
Reads 25 characters at s. If those characters are a valid TAI64N timestamp, stores the absolute date in a and returns 25. Else, returns 0. -- cgit v1.3.1