Clocks are used to measure time. bf(C++) has several predefined emi(clock)
types, defined in the tt(std::chrono) namespace.

Before using the tt(chrono) clocks the tthi(chrono) header file must be
included.

`tt(Clock)' clock-types are used to define points in time and define the
following sub-types:
    itemization(
    it() tt(Clock::duration): the clock's time granularity type (by default
        using tt(nanoseconds). E.g., tt(system_clock::duration oneDay{ 24h });

    it() tt(Clock::period): the clock's tt(std::ratio) type. E.g., 
        tt(system_clock::period::den);

    it() tt(Clock::rep): the type storing amounts of time. By default using
        tt(int64_t)). E.g., tt(system_clock::rep amount);

    it() tt(Clock::time_point): the type storing time points (covered in the
        next section). By default using tt(time_point<system_clock,
        nanoseconds>) E.g., tt(system_clock::time_point start).
    )

    All clocks have a member ti(now) returning the clock type's
tt(time_point) corresponding to the current time (relative to the clock's
epoch). It is a static member which can be used like this:
    tt(system_clock::time_point tp = system_clock::now()).

Four clock types are defined in the chrono namespace:
    itemization(
        iti(system_clock) is the `wall clock', using the system's real time
            clock;
        iti(steady_clock) is a clock whose time increases in parallel with the
            increase of real time;
        iti(high_resolution_clock) is the computer's fastest clock (i.e., the
            clock having the shortest timer-tick interval). In practice this is
            the same clock as tt(system_clock).
        iti(file_clock): used for time specifications of file-system
            elements. tt(File_clock) time specifications use a different
            starting (epoch) time than the other clocks, but it's easy to
            convert tt(file_clock) times to/from other clock types.
    )

In addition to the member tt(now) the classes tt(system_clock) and
tt(high_resolution_clock) (referred to as tt(Clock) below) provide two static
members:
    itemization(
    itht(to_time_t)
       (std::time_t Clock::to_time_t(Clock::time_point const &tp))nl() 
       a tt(std::time_t)hi(time_t) value (the same type as returned by bf(C)'s
        bf(time)(2) function) converting a tt(time_point) value to a
        tt(time_t) value;

    itht(from_time_t)
       (Clock::time_point Clock::from_time_t(std::time_tvseconds))nl() 
       the opposite conversion: returning a tt(time_point) corresponding to a
        tt(time_t) value.
    )

For example:
        verb(    system_clock::time_point now = system_clock::now();
    time_t value = system_clock::to_time_t(now);
    system_clock::time_point now2 = system_clock::from_time_t(value);

    // now2 != now since time_t uses seconds, not nanoseconds    )
