Time: 64bit UTC Time handling.
[Query Object Framework]

Detailed Description

Universal time is the 'one true time' that is independent of one's location on planet Earth. It is measured in seconds from midnight January 1, 1970 in localtime-Greenwich (GMT).

QofTime uses a signed 64bit integer to count the seconds, which differs from GTimeVal (32bit) and most other time handling routines (which only count from the epoch).

A QofTime where qt_sec == +1 therefore represents one second after midnight on 1st January 1970 - the epoch. Negative values of QofTime->qt_sec represent times before one second before midnight on 31st December 1969. Support for times before 1st Jan Year 1 are included.

Note:
GTime is defined to always be a 32bit integer, unlike time_t which may be 64bit on some systems. Therefore, GTime will overflow in the year 2038. (A 32bit time_t will overflow at 2038-01-19T03:14:07Z to be precise, at which point it will likely wrap around to 20:45:52 UTC on December 13, 1901.)
QofTime is defined as 64bit on all systems and will not overflow until the year 292,471,208,679 (not counting leap years). i.e. approx. 9223372036854775808 / (60*60*24*365). This also means that some values of QofTime cannot be converted to a time_t on systems where time_t is defined as 32bit.

Note:
Most conversions of QofTime can cause a loss of data. GDate contains no time data, time_t varies between platforms and struct tm does not include fractions of a second. Avoid converting back and forth between time formats. All conversions between QofTime and time_t, struct tm or other 32bit time implementations must check the return value of QofTime functions to ensure the QofTime was within the range supported by the 32bit type.
QofTime is not directly equivalent to GTimeVal - a QofTime can go further into the future. However, within the range supported by GTimeVal and GTime (a 32bit integer), the value of QofTime->qt_sec is always identical to GTimeVal->tv_sec.

The use of signed values and the handling of times prior to the epoch means that a QofTime with zero values can no longer be assumed to be invalid or used alone to denote an init value. QofTime is therefore an opaque type. QofTime and QofDate functions set and check QofTime validity as needed.

QofTime is always and only concerned with seconds. All date or calendar handling is performed using QofDate.

Since:
v0.7.0


Files

file  qoftime.h
 64bit UTC Time handling routines

Modules

 Date: 64bit UTC date handling.

Data Structures

struct  timespec64

QofTime functions.

typedef struct QofTime64 QofTime
 Use a 64-bit signed int QofTime.
typedef gint64 QofTimeSecs
 Replacement for time_t.
void qof_time_add_secs (QofTime *qt, QofTimeSecs secs)
 Add (or subtract) seconds from a QofTime.
QofTime * qof_time_add_secs_copy (QofTime *qt, QofTimeSecs secs)
 Create a new QofTime, secs different to an original.
QofTime * qof_time_new (void)
 create an empty QofTime
QofTime * qof_time_copy (const QofTime *qt)
 Create a copy of a QofTime.
void qof_time_free (QofTime *qt)
 Free a QofTime when no longer required.
void qof_time_set_secs (QofTime *time, QofTimeSecs secs)
 Set the number of seconds.
void qof_time_set_nanosecs (QofTime *time, glong nano)
 Set the number of seconds.
QofTimeSecs qof_time_get_secs (const QofTime *time)
 Get the number of seconds.
glong qof_time_get_nanosecs (const QofTime *time)
 Get the number of seconds.

QofTime manipulation

gboolean qof_time_equal (const QofTime *ta, const QofTime *tb)
gint qof_time_cmp (const QofTime *ta, const QofTime *tb)
QofTime * qof_time_diff (const QofTime *ta, const QofTime *tb)
 difference between two QofTimes.
QofTime * qof_time_abs (QofTime *t)
gboolean qof_time_is_valid (const QofTime *qt)
QofTime * qof_time_from_time_t (time_t t, glong nanosecs)
QofTime * qof_time_set (QofTimeSecs t, glong nanosecs)
gboolean qof_time_to_time_t (QofTime *ts, time_t *t, glong *nanosecs)
QofTime * qof_time_from_tm (struct tm *tm, glong nanosecs)
 Convert a broken-down into a QofTime.
gboolean qof_time_to_gtimeval (QofTime *qt, GTimeVal *gtv)
 Convert a QofTime to a GTimeVal.
void qof_time_from_gtimeval (QofTime *qt, GTimeVal *gtv)
 Convert a QofTime to a GTimeVal.
QofTime * qof_time_dmy_to_time (guint8 day, guint8 month, guint16 year)
gboolean qof_time_to_dmy (QofTime *t, guint8 *day, guint8 *month, guint16 *year)
GDate * qof_time_to_gdate (QofTime *time)
 Convert QofTime to GDate.
QofTime * qof_time_from_gdate (GDate *date)
 Convert a GDate to a QofTime.

Time Start/End Adjustment routines

Given a time value, adjust it to be the beginning or end of that day.

GTimeVal * qof_time_get_current_start (void)
QofTime * qof_time_get_current (void)
 Get the current QofTime.
gboolean qof_time_set_day_middle (QofTime *t)
 set the given QofTime to midday on the same day.
gboolean qof_time_set_day_start (QofTime *time)
 set the given QofTime to the first second of that day.
gboolean qof_time_set_day_end (QofTime *time)
 set the given QofTime to the last second of that day.
guint8 qof_time_last_mday (QofTime *ts)

Today's Date

QofTime * qof_time_get_today_start (void)
QofTime * qof_time_get_today_end (void)
gchar * qof_time_stamp_now (void)

Defines

#define QOF_MOD_TIME   "qof-time"
#define QOF_NSECS   1000000000

Typedefs

typedef struct timespec64 Timespec

Define Documentation

#define QOF_MOD_TIME   "qof-time"

log module name

Definition at line 94 of file qoftime.h.

#define QOF_NSECS   1000000000

number of nanoseconds per second. 10^9

Definition at line 105 of file qoftime.h.

Typedef Documentation

typedef struct QofTime64 QofTime

Use a 64-bit signed int QofTime.

QofTime is a lot like the unix 'struct timespec' except that it uses a 64-bit signed int to store the seconds. This should adequately cover dates in the distant future as well as the distant past, as long as these are not more than a couple of dozen times the age of the universe. Values of this type can range from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

Definition at line 120 of file qoftime.h.

typedef gint64 QofTimeSecs

Replacement for time_t.

Prevents overflows by making all values 64bit on all platforms.

(time_t will overflow on 32bit systems in 2038)

Definition at line 129 of file qoftime.h.

Function Documentation

QofTime* qof_time_abs ( QofTime *  t  ) 

Normalise a QofTime to an absolute value.

Parameters:
t the QofTime to normalise.
Returns:
the normalised QofTime t.

Definition at line 196 of file qoftime.c.

00197 {
00198     g_return_val_if_fail (qt, NULL);
00199     return time_normalize (qt);
00200 }

void qof_time_add_secs ( QofTime *  qt,
QofTimeSecs  secs 
)

Add (or subtract) seconds from a QofTime.

Parameters:
qt A valid QofTime.
secs A 64bit number of seconds to add (or subtract if secs is negative) from the QofTime.
The QofTime is altered in place. To assign the new value to a new QofTime, use qof_time_add_secs_copy

Definition at line 65 of file qoftime.c.

00066 {
00067     g_return_if_fail (qt);
00068     g_return_if_fail (qt->valid);
00069     qt->qt_sec += secs;
00070 }

QofTime* qof_time_add_secs_copy ( QofTime *  qt,
QofTimeSecs  secs 
)

Create a new QofTime, secs different to an original.

Parameters:
qt a valid QofTime to use as the base.
secs a 64bit number of seconds to add (or subtract if secs is negative) from the original to create the copy.
Returns:
a new, valid, QofTime that is secs different to the original.

Definition at line 73 of file qoftime.c.

00074 {
00075     QofTime *copy;
00076 
00077     g_return_val_if_fail (qt, NULL);
00078     g_return_val_if_fail (qt->valid, NULL);
00079     copy = qof_time_copy (qt);
00080     copy->qt_sec += secs;
00081     return copy;
00082 }

gint qof_time_cmp ( const QofTime *  ta,
const QofTime *  tb 
)

comparison: if (ta < tb) -1; else if (ta > tb) 1; else 0;

Definition at line 165 of file qoftime.c.

00166 {
00167     g_return_val_if_fail (ta->valid && tb->valid, -1);
00168     if (ta == tb)
00169         return 0;
00170     if (ta->qt_sec < tb->qt_sec)
00171         return -1;
00172     if (ta->qt_sec > tb->qt_sec)
00173         return 1;
00174     if (ta->qt_nsec < tb->qt_nsec)
00175         return -1;
00176     if (ta->qt_nsec > tb->qt_nsec)
00177         return 1;
00178     return 0;
00179 }

QofTime* qof_time_copy ( const QofTime *  qt  ) 

Create a copy of a QofTime.

Parameters:
qt A valid QofTime to copy.
Returns:
NULL on error, otherwise a new, valid and normalised QofTime set to the same time as the original.

Definition at line 223 of file qoftime.c.

00224 {
00225     g_return_val_if_fail (qt, NULL);
00226     g_return_val_if_fail (qt->valid, NULL);
00227     return qof_time_set (qt->qt_sec, qt->qt_nsec);
00228 }

QofTime* qof_time_diff ( const QofTime *  ta,
const QofTime *  tb 
)

difference between two QofTimes.

Results are normalised ie qt_sec and qt_nsec of the result have the same size abs(result.qt_nsec) <= 1000000000

Returns:
a new QofTime of the difference. The caller must free the difference QofTime when done.

Definition at line 182 of file qoftime.c.

00183 {
00184     QofTime *retval;
00185 
00186     g_return_val_if_fail (ta->valid && tb->valid, NULL);
00187     retval = g_new0 (QofTime, 1);
00188     retval->qt_sec = ta->qt_sec - tb->qt_sec;
00189     retval->qt_nsec = ta->qt_nsec - tb->qt_nsec;
00190     retval->valid = TRUE;
00191     time_normalize (retval);
00192     return retval;
00193 }

QofTime* qof_time_dmy_to_time ( guint8  day,
guint8  month,
guint16  year 
)

Convert a day, month, and year to a QofTime.

Limited to the range of a GDate.

Parameters:
day day of month, 1 to 31.
month Decimal number of month, 1 to 12.
year signed short containing the year. This value is safe for all dates within the range of a GDate.
Returns:
NULL on error, otherwise the converted QofTime.

Definition at line 457 of file qoftime.c.

00458 {
00459     GDate *d;
00460     QofTime *qt;
00461 
00462     g_return_val_if_fail (g_date_valid_dmy (day, month, year), NULL);
00463     d = g_date_new_dmy (day, month, year);
00464     qt = qof_time_from_gdate (d);
00465     return qt;
00466 }

gboolean qof_time_equal ( const QofTime *  ta,
const QofTime *  tb 
)

strict equality

Definition at line 148 of file qoftime.c.

00149 {
00150     if (ta == tb)
00151         return TRUE;
00152     if (!ta)
00153         return FALSE;
00154     if (!tb)
00155         return FALSE;
00156     g_return_val_if_fail (ta->valid && tb->valid, FALSE);
00157     if (ta->qt_sec != tb->qt_sec)
00158         return FALSE;
00159     if (ta->qt_nsec != tb->qt_nsec)
00160         return FALSE;
00161     return TRUE;
00162 }

QofTime* qof_time_from_gdate ( GDate *  date  ) 

Convert a GDate to a QofTime.

Warning:
the QofTime is set to the first second of the particular day, UTC.
Parameters:
date The GDate to convert
Returns:
a valid QofTime or NULL on error.

Definition at line 312 of file qoftime.c.

00313 {
00314     struct tm gtm;
00315     QofTime *qt;
00316     QofDate *qd;
00317 
00318     g_return_val_if_fail (date, NULL);
00319     g_date_to_struct_tm (date, &gtm);
00320     qd = qof_date_from_struct_tm (&gtm);
00321     qt = qof_date_to_qtime (qd);
00322     qof_date_free (qd);
00323     return qt;
00324 }

void qof_time_from_gtimeval ( QofTime *  qt,
GTimeVal *  gtv 
)

Convert a QofTime to a GTimeVal.

Safe for all dates supported by a valid GTimeVal.

Parameters:
qt QofTime to set.
gtv GTimeVal to convert

Definition at line 290 of file qoftime.c.

00291 {
00292     qt->qt_sec = (QofTimeSecs) gtv->tv_sec;
00293     qt->qt_nsec = gtv->tv_usec * 1000;
00294     qt->valid = TRUE;
00295     time_normalize (qt);
00296 }

QofTime* qof_time_from_time_t ( time_t  t,
glong  nanosecs 
)

Turns a time_t into a QofTime

Note:
On some platforms, time_t is only 32bit. Use QofTimeSecs instead.
Parameters:
t integer seconds since the epoch.
nanosecs number of nanoseconds
Returns:
pointer to a newly allocated QofTime.

Definition at line 231 of file qoftime.c.

00232 {
00233     return qof_time_set (t, nanosecs);
00234 }

QofTime* qof_time_from_tm ( struct tm *  tm,
glong  nanosecs 
)

Convert a broken-down into a QofTime.

struct tm broken-down time does not support fractions of a second.

Conversion of a QofTime to a struct tm is not supported because of the inherent data loss.

Parameters:
tm broken-down time structure.
nanosecs Fractions of a second.
Returns:
a newly allocated QofTime or NULL on error.

Definition at line 258 of file qoftime.c.

00259 {
00260     QofDate *qd;
00261     QofTime *qt;
00262 
00263     /* avoids use of gmtime_r and therefore time_t */
00264     qd = qof_date_from_struct_tm (qtm);
00265     qd->qd_nanosecs = nanosecs;
00266     qt = qof_date_to_qtime (qd);
00267     qof_date_free (qd);
00268     return qt;
00269 }

QofTime* qof_time_get_current ( void   ) 

Get the current QofTime.

Current implementations can only provide a long number of seconds (max: 2,147,483,647) and the number of microseconds (10^-6) not nanoseconds (10^-9).

Returns:
a newly allocated, valid, QofTime of the current time.
Todo:
use to replace qof_time_get_current_start

Definition at line 362 of file qoftime.c.

00363 {
00364     QofTime *now;
00365     GTimeVal gnow;
00366 
00367     now = qof_time_new ();
00368     g_get_current_time (&gnow);
00369     qof_time_from_gtimeval (now, &gnow);
00370     return now;
00371 }

GTimeVal* qof_time_get_current_start ( void   ) 

Todo:
move to a private header; used by qofdate.c and test-date.c

Todo:
replace with QofDate

Definition at line 345 of file qoftime.c.

00346 {
00347     GTimeVal *current;
00348     struct tm tm;
00349 
00351     current = g_new0 (GTimeVal, 1);
00352     g_get_current_time (current);
00353     /* OK to use time_t for current time. */
00354     tm = *gmtime_r (&current->tv_sec, &tm);
00355     current->tv_sec -= tm.tm_sec;
00356     current->tv_sec -= tm.tm_min * 60;
00357     current->tv_sec -= tm.tm_hour * 60 * 60;
00358     return current;
00359 }

glong qof_time_get_nanosecs ( const QofTime *  time  ) 

Get the number of seconds.

Parameters:
time pointer to a QofTime time, created with qof_time_new();
Returns:
long int number of nanoseconds.

Definition at line 141 of file qoftime.c.

00142 {
00143     g_return_val_if_fail (qt->valid == TRUE, 0);
00144     return qt->qt_nsec;
00145 }

QofTimeSecs qof_time_get_secs ( const QofTime *  time  ) 

Get the number of seconds.

Parameters:
time pointer to a QofTime time, created with qof_time_new();
Returns:
Signed 64bit number of seconds.

Definition at line 133 of file qoftime.c.

00134 {
00135     g_return_val_if_fail (qt, 0);
00136     g_return_val_if_fail (qt->valid == TRUE, 0);
00137     return qt->qt_sec;
00138 }

QofTime* qof_time_get_today_end ( void   ) 

returns a QofTime of the last second of today.

Definition at line 413 of file qoftime.c.

00414 {
00415     QofTime *qt;
00416 
00417     qt = qof_time_get_today_start ();
00418     qt->qt_sec += SECS_PER_DAY - 1;
00419     return qt;
00420 }

QofTime* qof_time_get_today_start ( void   ) 

return a QofTime of the first second of today.

Definition at line 402 of file qoftime.c.

00403 {
00404     QofTime *qt;
00405 
00406     qt = qof_time_get_current ();
00407     if (!qof_time_set_day_start (qt))
00408         return NULL;
00409     return qt;
00410 }

guint8 qof_time_last_mday ( QofTime *  ts  ) 

Return the number of the last day of the month for the value contained in the QofTime.

Todo:
remove GDate limits.
Only usable within the range of dates supported by GDate.
Returns:
zero on error.

Definition at line 423 of file qoftime.c.

00424 {
00425     GDate *d;
00426     GDateMonth m;
00427     GDateYear y;
00428 
00429     g_return_val_if_fail (qt, 0);
00430     d = qof_time_to_gdate (qt);
00431     if (!d)
00432         return 0;
00433     m = g_date_get_month (d);
00434     y = g_date_get_year (d);
00435     return g_date_get_days_in_month (m, y);
00436 }

QofTime* qof_time_new ( void   ) 

create an empty QofTime

The QofTime becomes the property of the caller and needs to be freed with qof_time_free when no longer required.

Definition at line 46 of file qoftime.c.

00047 {
00048     QofTime *qt;
00049 
00050     qt = g_new0 (QofTime, 1);
00051     qt->valid = FALSE;
00052     return qt;
00053 }

QofTime* qof_time_set ( QofTimeSecs  t,
glong  nanosecs 
)

Turns a QofTimeSecs into a QofTime

An alternative call that combines qof_time_set_secs and qof_time_set_nanosecs.

Parameters:
t 64bit integer number of seconds (t == 0 at the epoch, use negative values for previous times.)
nanosecs number of nanoseconds
Returns:
pointer to a newly allocated (and validated) QofTime.

Definition at line 210 of file qoftime.c.

00211 {
00212     QofTime *qt;
00213 
00214     qt = qof_time_new ();
00215     qt->qt_sec = t;
00216     qt->qt_nsec = nanosecs;
00217     qt->valid = TRUE;
00218     time_normalize (qt);
00219     return qt;
00220 }

gboolean qof_time_set_day_end ( QofTime *  time  ) 

set the given QofTime to the last second of that day.

This routine is limited to dates supported by GDate.

Todo:
remove GDate limits.
Returns:
FALSE on error, otherwise TRUE.

Definition at line 327 of file qoftime.c.

00328 {
00329     if (!qof_time_set_day_start (qt))
00330         return FALSE;
00331     qt->qt_sec += (SECS_PER_DAY - 1);
00332     return TRUE;
00333 }

gboolean qof_time_set_day_middle ( QofTime *  t  ) 

set the given QofTime to midday on the same day.

This routine is limited to dates supported by GDate.

Todo:
remove GDate limits.
Returns:
FALSE on error, otherwise TRUE

Definition at line 336 of file qoftime.c.

00337 {
00338     if (!qof_time_set_day_start (qt))
00339         return FALSE;
00340     qt->qt_sec += (SECS_PER_DAY / 2);
00341     return TRUE;
00342 }

gboolean qof_time_set_day_start ( QofTime *  time  ) 

set the given QofTime to the first second of that day.

This routine is limited to dates supported by GDate.

Todo:
remove GDate limits.
Returns:
FALSE on error, otherwise TRUE.

Definition at line 374 of file qoftime.c.

00375 {
00376     QofDate *qd;
00377     QofTimeSecs c;
00378     
00379     g_return_val_if_fail (qt, FALSE);
00380     qd = qof_date_from_qtime (qt);
00381     if (qd->qd_year < 1970)
00382     {
00383         c = QOF_DAYS_TO_SEC(qd->qd_yday);
00384         c -= QOF_DAYS_TO_SEC(days_between (1970, qd->qd_year));
00385         c -= qd->qd_gmt_off;
00386         qt->qt_sec = c;
00387         qt->qt_nsec = 0;
00388     }
00389     if (qd->qd_year >= 1970)
00390     {
00391         c = QOF_DAYS_TO_SEC(qd->qd_yday);
00392         c += QOF_DAYS_TO_SEC(days_between (1970, qd->qd_year));
00393         c -= qd->qd_gmt_off;
00394         qt->qt_sec = c;
00395         qt->qt_nsec = 0;
00396     }
00397     qof_date_free (qd);
00398     return TRUE;
00399 }

void qof_time_set_nanosecs ( QofTime *  time,
glong  nano 
)

Set the number of seconds.

Parameters:
time pointer to a QofTime time, created with qof_time_new();
nano long int number of nanoseconds.

Definition at line 125 of file qoftime.c.

00126 {
00127     qt->qt_nsec = nano;
00128     qt->valid = TRUE;
00129     time_normalize (qt);
00130 }

void qof_time_set_secs ( QofTime *  time,
QofTimeSecs  secs 
)

Set the number of seconds.

Parameters:
time pointer to a QofTime time, created with qof_time_new();
secs Signed 64bit number of seconds where zero represents midnight at the epoch: 00:00:00 01/01/1970.

Definition at line 117 of file qoftime.c.

00118 {
00119     qt->qt_sec = secs;
00120     qt->valid = TRUE;
00121     time_normalize (qt);
00122 }

gchar* qof_time_stamp_now ( void   ) 

Return the current time in UTC textual format.

Returns:
A pointer to the generated string.
Note:
The caller owns this buffer and must free it when done.

Definition at line 469 of file qoftime.c.

00470 {
00471     gint len;
00472     struct tm qtm;
00473     time_t t;
00474     gchar test[MAX_DATE_LENGTH];
00475     const gchar *fmt;
00476 
00477     ENTER (" ");
00478     t = time (NULL);
00479     qtm = *gmtime_r (&t, &qtm);
00480     fmt = qof_date_format_get_format (QOF_DATE_FORMAT_UTC);
00481     len = strftime (test, MAX_DATE_LENGTH, fmt, &qtm);
00482     if (len == 0 && test[0] != '\0')
00483     {
00484         LEAVE (" strftime failed.");
00485         return NULL;
00486     }
00487     LEAVE (" ");
00488     return g_strdup (test);
00489 }

gboolean qof_time_to_dmy ( QofTime *  t,
guint8 *  day,
guint8 *  month,
guint16 *  year 
)

Convert a QofTime to day, month and year.

Usable for all QofTime values within the range of GDate.

Todo:
Remove GDate limits and use QofDate.
Parameters:
t The QofTime to use.
day Pointer to a integer to hold day of month, 1 to 31.
month Decimal number of month, 1 to 12.
year signed short containing the year. This value is safe for all dates within the range of a GDate.
Returns:
FALSE if the time cannot be converted, otherwise TRUE.

Definition at line 439 of file qoftime.c.

00441 {
00442     GDate *d;
00443 
00444     d = qof_time_to_gdate (qt);
00445     if (!d)
00446         return FALSE;
00447     if (day)
00448         *day = g_date_get_day (d);
00449     if (month)
00450         *month = g_date_get_month (d);
00451     if (year)
00452         *year = g_date_get_year (d);
00453     return TRUE;
00454 }

GDate* qof_time_to_gdate ( QofTime *  time  ) 

Convert QofTime to GDate.

Warning:
The GDate will lose time-related data within the QofTime. i.e. converting a QofTime to a GDate and back to a QofTime causes the final QofTime to be set to the start of the particular day, UTC.
Parameters:
time The QofTime to convert
Returns:
a valid GDate or NULL on error.

Definition at line 299 of file qoftime.c.

00300 {
00301     QofDate *qd;
00302     GDate *d;
00303 
00304     qd = qof_date_from_qtime (qt);
00305     d = g_date_new_dmy (qd->qd_mday, qd->qd_mon, qd->qd_year);
00306     if (g_date_valid (d))
00307         return d;
00308     return NULL;
00309 }

gboolean qof_time_to_gtimeval ( QofTime *  qt,
GTimeVal *  gtv 
)

Convert a QofTime to a GTimeVal.

Safe for dates between 1st January Year 1 and 31st December 2037.

Parameters:
qt QofTime to convert
gtv GTimeVal to set, left unchanged if an error occurs.
Returns:
TRUE on success, FALSE on error.

Definition at line 272 of file qoftime.c.

00273 {
00274     if (!qt->valid)
00275     {
00276         PERR (" invalid QofTime passed");
00277         return FALSE;
00278     }
00279     if (qt->qt_sec > G_MAXLONG)
00280     {
00281         PERR (" QofTime out of range for GTimeVal");
00282         return FALSE;
00283     }
00284     gtv->tv_sec = (glong) qt->qt_sec;
00285     gtv->tv_usec = qt->qt_nsec;
00286     return TRUE;
00287 }

gboolean qof_time_to_time_t ( QofTime *  ts,
time_t *  t,
glong *  nanosecs 
)

Tries to turn a QofTime into a time_t

Note:
CARE: QofTime is 64bit, time_t might be 32bit. GDate has a wider range. time_t may be defined as an integer on some platforms, causing data loss.
Parameters:
ts A 64bit QofTime.
t pointer to a time_t to store result.
nanosecs pointer to a variable to store the nanoseconds, if any, from the QofTime conversion.
Returns:
FALSE on error or if the QofTime is before the epoch or outside the range of time_t, otherwise TRUE.

Definition at line 237 of file qoftime.c.

00238 {
00239     if (!qt->valid)
00240         return FALSE;
00241     if (qt->qt_sec < 0)
00242         return FALSE;
00243     if (qt->qt_nsec > 0)
00244     {
00245         *nanosecs = qt->qt_nsec;
00246     }
00247     if ((sizeof (qt->qt_sec) > sizeof (time_t))
00248         && (qt->qt_sec > G_MAXINT32))
00249     {
00250         PERR (" QofTime too large for time_t on this platform.");
00251         return FALSE;
00252     }
00253     *t = qt->qt_sec;
00254     return TRUE;
00255 }

Generated on Thu Jan 31 22:50:27 2008 for QOF by  doxygen 1.5.4