Time points obtained using ti(file_clock) differ from time points obtained
using the system clock: time points using tt(file_clock) are based on an epoch
that lies beyond the starting time point of the system clock (Jan 1, 00:00:00
1970) that is used by the system clock (Jan 1 00:00:00 2174). The two epochs
can be positioned on a time scale with the present somewhere in between:
    verb
(    <------|-----------------------|-----------------------|------->
      system_clock's -------->  present <--------    file_clock's
       epoch starts  positive            negative     epoch starts
                      count               count)

The tt(file_clock) has its own peculiarities: the static member tt(now) is
available, as are some non-static members: additions and subtractions of
durations and the member tt(time_since_epoch) can all be used, but the members 
tt(to_time_t) and tt(from_time_t) are not available.

Since tt(to_time_t) is not available for tt(file_clock) how can we show the
time or obtain the time's components of a tt(time_point<file_clock>) object?

Currently, there are two ways to accomplish that: compute the correction `by
hand' or use the static ti(file_clock::to_sys) function converting a
    hi(time_point<file_clock>)
tt(file_clock) time point to a tt(time_point) as used by tt(system_clock,
steady_clock,) and tt(high_resolution_clock).
    
Computing the difference between the epochs we find
6'437'663'999 seconds, which we can add to the obtained time since the
tt(file_clock's) epoch to obtain the time since the tt(system_clock's)
epoch. If tt(timePt) holds the duration since the tt(file_clock) epoch then
        verb(    6'437'663'999 + system_clock::to_time_t(
                        time_point<system_clock>{ nanoseconds(timePt) }))

    equals the number of seconds since the tt(system_clock's) epoch.

The potential drawback of this procedure is that, as tt(file_clock's)
name starts with underscores, the begin of its epoch might change. By using
the tt(now) members of both clocks this drawback is avoided:
        verb(    auto systemNow = system_clock::now().time_since_epoch();
    auto fileNow = file_clock::now().time_since_epoch();
    time_t diff = (systemNow - fileNow) / 1'000'000'000;

    time_t seconds = diff + system_clock::to_time_t(
                        time_point<system_clock>{ nanoseconds(timePt) });)

Although being able to compute the time-shifts yourself is attractive from
an understanding point of view, it's maybe also a bit (too) cumbersome for
daily practices. The static function tt(file_clock::to_sys) can be used to
convert tt(file_clock::time_points) to tt(system_clock:::time_points). The
tt(file_clock::to_sys) function is covered in section ref(FREEFS).

COMMENT( see examples/lastwritetime[2].cc)




