Seconds since epoch for a specific date

Question

Currently, I have A solution and another semi-solution. The semi-solution is linked here, Get seconds since epoch in Linux but that gives the time since epoch for the current datetime. I need to have it tell me the seconds since epoch for a specified date instead. I do have a function for this, however I can't find the original post for it,

std::tm t = {};
std::istringstream ss(dateBuf);
ss >> std::get_time(&t, "%Y-%m-%d");
double seconds = (double)(std::mktime(&t));

There are a few issues I have with it though. Currently, dateBuf = "2020-01-01"; and I require it to be able to handle not just days, but hours, minutes, seconds... Also, I am hoping there is another way of doing this without allocating memory every time to make a new std::tm and std::istringstream and then pushing ss into it. I am wondering if there is a way to go straight from char datebuf[] to a double/long double with the seconds as the value. For all intensive purposes, the program will go over this statement many, many times to convert the dates to seconds and this just seems inefficient. Something such as

long double SecondsSinceEpoch(const char* date){
    //Taking in a date such as "2020-01-01 00:00:00" (Local Time)
    //Will return the value 1577836800 (GMT) and Local time of 1577797200

    //And also be able to take in a simpler date such as "2020-01-01"
}

Answer 1

Here's the general purpose solution using the preview C++20 chrono library:

#include "date/tz.h"
#include <iostream>
#include <sstream>

long double
SecondsSinceEpoch(const char* date)
{
    //Taking in a date such as "2020-01-01 00:00:00" (Local Time)
    //And also be able to take in a simpler date such as "2020-01-01"
    //returns -1 on error
    using namespace date;
    using namespace std;
    using namespace std::chrono;

    istringstream in{date};
    local_days tpd;
    in >> parse("%F", tpd);
    if (in.fail())
        return -1;
    seconds s{};
    in >> parse(" %T", s);
    zoned_time zt{current_zone(), tpd + s};
    return zt.get_sys_time().time_since_epoch().count();
}

The expensive parts are calling current_zone() and parsing out of an istringstream (which may create a long string on the heap, depending on the implementation and the input).

The above can be made faster if we can substitute in a constant UTC offset for the time zone, and if we create customized parsing logic that doesn't have to do much error checking.

What this library excels at is taking the {y, m, d, h, M, s} integral values and turning them into a count of seconds. So if you can obtain those integral values more efficiently than strptime (or it's equivalent in this library), including applying the UTC offset to the local time, then this library can translate those 6 fields into a count of seconds with very few cpu clock cycles.

Update

One thing you can do if your time zone is constant is to just look it up once:

static auto tz = current_zone();
zoned_time zt{tz, tpd + s};

or:

static auto tz = locate_zone("Australia/Sydney");
zoned_time zt{tz, tpd + s};

Both of these options are roughly equivalent to each other in terms of performance (assuming your current time zone is always "Australia/Sydney".

If you do your own scanning into integral types, then turning those ints into dates looks more like:

// Return {y, m, d, h, M, s}
std::array<int, 6>
scan(const char* date);

long double
SecondsSinceEpoch(const char* date)
{
    //Taking in a date such as "2020-01-01 00:00:00" (Local Time)
    //And also be able to take in a simpler date such as "2020-01-01"
    //returns -1 on error
    using namespace date;
    using namespace std::chrono;

    auto a = scan(date);  // where you write scan
    auto tp = local_days{year{a[0]}/a[1]/a[2]} + hours{a[3]}
              + minutes{a[4]} + seconds{a[5]};
    static auto tz = locate_zone("Australia/Sydney");
    zoned_time zt{tz, tp};
    return zt.get_sys_time().time_since_epoch().count();
}

Use of the timezone lib does require some installation.