dadlldate_time

Library: dadlldate_time

This library contains common functionality that operates on date and time fields, values and constants

 function extern date.const.disp.to.store(
         domain daxch.dfor dfor,
         const string disp.field(),
         ref string store.field())
 pre   : true post  : store.field contains the value of disp.field as it should
be
        stored desc: : - expression with # will be copied unchanged
        - formatted date will be converted to a datenumber
          (converted to a string)
 function extern long date.const.enter.to.disp(
         domain daxch.dfor dfor,
         ref string disp.field())
 pre   : true return: whether disp.field is a valid date constant post  : ret =
true  ==> disp.field will contain the value as
        old(disp.field) should be displayed
        ret = false ==> disp.field will be left unchanged desc  : a correctly
entered date constant should be displayed as
        follows: - date.num() will be replaced by #
                 - [(+-)[n]] will be displayed by the indicated date
                   (formatted)
                 - formatted dates will be displayed unchanged
 function extern date.const.store.to.disp(
         domain daxch.dfor dfor,
         const string store.field(),
         ref string disp.field())
 pre   : true post  : disp.field contains the value of store.field as it should
      : be displayed: desc  : - expression with # will be copied unchanged
        - a datenumber will be converted to a formatted date
         (converted to a string)
 function extern long date.to.format(
         domain daxch.dfor dfor,
         long ndate )
 pre   : true return: dfor and ndate are valid ==> the formatted date
representation
                                     of ndate
        otherwise ==> ndate (ndate is regarded to be a date number)
 function extern string datestr.to.formatstr(
         domain daxch.dfor dfor,
         const string sdate() )
 pre   : true return: dfor and sdate are valid ==> the formatted date
representation
                                     of sdate (converted to a string)
        otherwise ==> sdate (sdate is regarded to be the string
                      representation of a date number)
 function extern long format.to.date(
         domain daxch.dfor dfor,
         long fdate )
 pre   : true return: dfor and fdate are valid ==> the date number of fdate
        otherwise ==> fdate desc  : if the year is in YY format the century must
be guessed:
        YY < 50 then 21st century else 20th century
 function extern string formatstr.to.datestr(
         domain daxch.dfor dfor,
         const string sfdate())
 pre   : true return: dfor is valid and sfdate is valid ==> the date number of
fdate
                                              as a string
        otherwise ==> str$(lval(sfdate)) (this might loose information) desc  :
if the year is in YY format the century must be guessed:
        YY < 50 then 21st century else 20th century
 function extern long get.date.format.length(domain daxch.dfor dfor)
 pre   : true return: the length of a date according to dfor,
         - 6 for a date number and a format with YY
         - 8 for a format with YYYY
         - 0 for an invalid format
 function extern get.next.interval(
         ref domain daxch.utc date.f,
         ref domain daxch.utc date.t )
 pre   : the parameters denote a time-interval post  : the parameters contain
the next interval, ie the interval
        starting at the end of the given interval and having the same
        length as the given one, or more 'precise':
        - date.f = old(date.t) AND
        - date.t = date.f + ( old(date.t) - old(date.f))
 function extern long hhmmss.to.secs(long hhmmss)
 return: hhmmss converted to # seconds since midnight
 function extern long secs.to.hhmmss(long secs)
 return:  secs (the number of seconds since midnight) converted to hhmmss
 function extern long utc.date.and.time.to.utc(
         domain daxch.date date,
         domain daxch.time time,
         ref domain daxch.utc utc.date )
 pre   : date and time contain a utc date/time;
        format of date: date number, format of time: hhmmss. return: True if the
utc date was converted successfully. post  : If return then utc.date contains
the same date/time
        as date and time, but in utc format. note  : No conversion from local
time to utc is done;
        only the date and time are reformatted into a single
        utc variable.
 function extern long utc.to.utc.date.and.time(
         domain daxch.utc utc.date,
         ref domain daxch.date date,
         ref domain daxch.time time)
 pre   : utc.date is a date in utc format. return: True if the utc date was
converted successfully. post  :If return then date and time contain the same
date/time
       as utc.date, but in a different format:
       format of date: date number, format of time: hhmmss. note  :No conversion
from utc to local time is done;
       only the utc.date is split up into two variables, because
       the audit server uses a separate date and time.