clock and time - C++11, 14 of n

C++11 provides chrono library to deal with clock and time.
1) Durations
std::chrono::duration<int> twentySeconds(20);
std::chrono::duration<double,std::ratio<60>> halfAMinute(0.5);
std::chrono::duration<long,std::ratio<1,1000>> oneMillisecond(1);
Predefined values:
namespace chrono {
    typedef duration<signed int-type >= 64 bits,nano> nanoseconds;
    typedef duration<signed int-type >= 55 bits,micro> microseconds;
    typedef duration<signed int-type >= 45 bits,milli> milliseconds;
    typedef duration<signed int-type >= 35 bits> seconds;
    typedef duration<signed int-type >= 29 bits,ratio<60>> minutes;
    typedef duration<signed int-type >= 23 bits,ratio<3600>> hours;
}

std::chrono::seconds twentySeconds(20);
std::chrono::hours aDay(24);

std::chrono::milliseconds oneMillisecond(1);

Duration supports +,-,*,/,%,<,>,<=,>=,== etc arithmetic operations

2)  Clock
Clock defines an epoch and a tick period (in millisecond, or in nanosecond).
C++11 provides three kinds of clock interfaces:

1. The system_clock represents timepoints associated with the usual real-time clock of the current system. This clock also provides convenience functions to_time_t() and from_time_t() to convert between any timepoint and the C system time type time_t, which means that you can convert into and from calendar times.
2. The steady_clock gives the guarantee that it never gets adjusted. Thus, timepoint values never decrease as the physical time advances, and they advance at a steady rate relative to real time.
3. The high_resolution_clock represents a clock with the shortest tick period possible on the current system.

Request interfaces for Clock:

3) Timepoints
With any of these clocks—or even with user-defined clocks—you can deal with timepoints, the timepoint defines as below:
namespace chrono {
    template <typename Clock,
    typename Duration = typename Clock::duration>
    class time_point;
}
4) ctime interfaces

5) Conversions between Timepoints and Calendar Time
#include <chrono>
#include <ctime>
#include <string>
// convert timepoint of system clock to calendar time string
inline std::string asString (const std::chrono::system_clock::time_point& tp)
{
    std::time_t t = std::chrono::system_clock::to_time_t(tp);
    std::string ts = ctime(&t); // convert to calendar time
    ts.resize(ts.size()-1); // skip trailing newline
    return ts;
}
// convert calendar time to timepoint of system clock
inline std::chrono::system_clock::time_point makeTimePoint (int year, int mon, int day, int hour, int min, int sec=0)
{
    struct std::tm t;
    t.tm_sec = sec; // second of minute (0 .. 59 and 60 for leap seconds)
    t.tm_min = min; // minute of hour (0 .. 59)
    t.tm_hour = hour; // hour of day (0 .. 23)
    t.tm_mday = day; // day of month (0 .. 31)
    t.tm_mon = mon-1; // month of year (0 .. 11)
    t.tm_year = year-1900; // year since 1900
    t.tm_isdst = -1; // determine whether daylight saving time
    std::time_t tt = std::mktime(&t);
    if (tt == -1) {
        throw "no valid system time";
    }
    return std::chrono::system_clock::from_time_t(tt);
}

auto tp1 = makeTimePoint(2010,01,01,00,00);
std::cout << asString(tp1) << std::endl;
auto tp2 = makeTimePoint(2011,05,23,13,44);
std::cout << asString(tp2) << std::endl;

6) Blocking with timers

• sleep_for() and sleep_until() are provided by this_thread to block threads
• try_lock_for() and try_lock_until() are provided to specify a maximum interval when waiting for a mutex
• wait_for() and wait_until() are provided to specify a maximum interval when waiting for a condition variable or a future