Operations on date and time with milliseconds accuracy - c++

Question

I need to take the current local time, including milliseconds, and pass it to some embedded device. This device has now idea about calendar time, but has its own timer with 1 ms accuracy. So, when this device receives the current timestamp, it opens log file and writes this timestamp to the beginning. From now, it writes different messages to the log, each one with number of milliseconds elapsed from this initial time. Finally, embedded device log file is uploaded to the host and should be parsed, with all relative time intervals converted back to full calendar time. The first part in the host program looks like this:
struct timestamp
{
int year; // 0-based
int month; // [1-12]
int day; // [1-31]
int hour; // [0-23]
int minute; // [0-59]
int sec; // [0-59]
int ms; // [0-999]
};
timestamp time_point_to_timestamp(std::chrono::time_point<std::chrono::system_clock> tp)
{
auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(tp);
auto fraction = tp - seconds;
auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(fraction);
time_t tt = std::chrono::system_clock::to_time_t(tp);
tm* ptm = localtime(&tt);
timestamp t;
t.year = ptm->tm_year + 1900;
t.month = ptm->tm_mon + 1;
t.day = ptm->tm_mday;
t.hour = ptm->tm_hour;
t.minute = ptm->tm_min;
t.sec = ptm->tm_sec;
t.ms = static_cast<int>(milliseconds.count());
return t;
}
void start()
{
timestamp ts = time_point_to_timestamp(std::chrono::system_clock::now());
// send ts to embedded device
// ...
}
Now, when I get the log from device back to the host, it looks like this:
2018 6 24 8 25 52 598 // start time ts
500 message 1 // ms elapsed from ts
2350 message 2 // ms elapsed from ts
...
I need to parse this file and convert every message, printing its full date and time. For example, 500 will be converted to:
2018 6 24 8 25 53 098
So, I need some way to convert timestamp to any C++ type, that allows to add time intervals to it (time_point, duration?), and print it in human readable form. My compiler supports C++14.

Answer 1

I'd do this:
int64_t to_epoch_ms(time_point<system_clock> tp)
{
return duration_cast<milliseconds>(tp.time_since_epoch()).count();
}
Then pass the milliseconds since epoch to the device, where it can be logged as e.g. 1529819166927. Adding milliseconds is trivial and fast, whether you do it directly using the int64_t or by converting back to a time_point:
time_point<system_clock> from_epoch_ms(int64_t ms)
{
return {milliseconds(ms)};
}
auto tp1 = from_epoch_ms(ms + 123);
auto tp1 = from_epoch_ms(ms) + milliseconds(456);