Наносекунды и Chrono C ++

У меня проблемы с созданием точки времени - и с тем, как представлять наносекунды ... Он отлично работает с микропроцессорами.

Это говорит мне, что ваш system_clock::time_point имеет точность грубее наносекунд (на llvm это микросекунды, в Windows 1/10 микросекунды). Самый простой способ добавить наносекунды к такому time_point:

auto tp = temp_time_point + nanoseconds (nsecs);

Это формирует time_point, который все еще основан на system_clock, но имеет точность "общего типа" system_clock::duration и nanoseconds, которая на практике будет просто nanoseconds.

Предположим, что все временные метки - GMT, UTC + 0

Теперь проблема в том, что mktime преобразуется из локального tm в UTC time_t. Но вы хотите преобразовать из типа поля UTC в последовательный тип UTC.

Это легко сделать в C ++ 20 (я знаю, что у вас его еще нет, выслушайте меня):

#include <chrono>
#include <iostream>
#include <sstream>

std::chrono::sys_time<std::chrono::nanoseconds>
XXXXX(std::string const& timestamp)
{
    using namespace std;
    using namespace std::chrono;
    istringstream temp_ss{timestamp};
    sys_time<nanoseconds> tp;
    temp_ss >> parse("%F %T", tp);
    return tp;
}

int
main()
{
    auto tp = XXXXX("2018-10-01 00:06:16.700000000");
    std::cout << tp.time_since_epoch().count() << "ns\n";
    std::string s = std::format("{:%F %T}", tp);
    std::cout << s << '\n';
}

Это преобразует string в chrono::time_point<system_clock, nanoseconds>, который, очевидно, отличается от вашего system_clock::time_point только тем, что ваш system_clock::time_point имеет более грубую точность, чем nanoseconds.

Затем format используется для преобразования time_point обратно в string.

Вывод:

1538352376700000000ns
2018-10-01 00:06:16.700000000

Теперь я знаю, что полностью соответствующий C ++ 20 <chrono> - редкость в наши дни (он скоро появится). Пока он не дойдет до этого места, существует библиотека <chrono> предварительного просмотра C ++ 20, которая обратно совместима с C ++. 11. Это бесплатно и с открытым исходным кодом. И требует очень мало синтаксических изменений:

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

date::sys_time<std::chrono::nanoseconds>
XXXXX(std::string const& timestamp)
{
    using namespace date;
    using namespace std;
    using namespace std::chrono;
    istringstream temp_ss{timestamp};
    sys_time<nanoseconds> tp;
    temp_ss >> parse("%F %T", tp);
    return tp;
}

int
main()
{
    using namespace date;
    auto tp = XXXXX("2018-10-01 00:06:16.700000000");
    std::cout << tp.time_since_epoch().count() << "ns\n";
    std::string s = format("%F %T", tp);
    std::cout << s << '\n';
}

Вывод:

1538352376700000000ns
2018-10-01 00:06:16.700000000

Вы работаете с прямым преобразованием текста в наносекундное разрешение. По сути, есть две ключевые библиотеки:

• CCTZ некоторых инженеров Google, хотя (как и многие другие проекты) не является официально выпущенным продуктом Google.

• date Ховарда Хиннанта, который, вероятно, ответит здесь, прежде чем я закончу печатать; его библиотека является основой содержимого для этого в C ++ 20

Я обернул обе версии для R (через Rcpp), и у меня есть много примеров. Но есть также примеры в двух репозиториях, так что, может быть, начать с них?

Итак, из-за отсутствия лучших примеров CCTZ, здесь используется пакет R; вы видите входы:

R> library(RcppCCTZ)
R> example(parseDatetime)

prsDttR> ds <- getOption("digits.secs")

prsDttR> options(digits.secs=6) # max value

prsDttR> parseDatetime("2016-12-07 10:11:12",        "%Y-%m-%d %H:%M:%S")   # full seconds
[1] "2016-12-07 10:11:12 UTC"

prsDttR> parseDatetime("2016-12-07 10:11:12.123456", "%Y-%m-%d %H:%M:%E*S") # fractional seconds
[1] "2016-12-07 10:11:12.123456 UTC"

prsDttR> parseDatetime("2016-12-07T10:11:12.123456-00:00")  ## default RFC3339 format
[1] "2016-12-07 10:11:12.123456 UTC"

prsDttR> now <- trunc(Sys.time())

prsDttR> parseDatetime(formatDatetime(now + 0:4))               # vectorised
[1] "2020-05-01 02:16:27 UTC" "2020-05-01 02:16:28 UTC"
[3] "2020-05-01 02:16:29 UTC" "2020-05-01 02:16:30 UTC"
[5] "2020-05-01 02:16:31 UTC"

prsDttR> options(digits.secs=ds)
R> 

Вызывается функция синтаксического анализатора (и игнорируют биты, связанные с R)

Rcpp::DatetimeVector parseDatetime(Rcpp::CharacterVector svec,
                                   std::string fmt = "%Y-%m-%dT%H:%M:%E*S%Ez",
                                   std::string tzstr = "UTC") {
    cctz::time_zone tz;
    load_time_zone(tzstr, &tz);
    sc::system_clock::time_point tp;
    cctz::time_point<cctz::sys_seconds> unix_epoch =
        sc::time_point_cast<cctz::sys_seconds>(sc::system_clock::from_time_t(0));

    // if we wanted a 'start' timer
    //sc::system_clock::time_point start = sc::high_resolution_clock::now();

    auto n = svec.size();
    Rcpp::DatetimeVector dv(n, tzstr.c_str());
    for (auto i=0; i<n; i++) {
        std::string txt(svec(i));

        if (!cctz::parse(fmt, txt, tz, &tp)) Rcpp::stop("Parse error on %s", txt);

        // time since epoch, with fractional seconds added back in
        // only microseconds guaranteed to be present
        double dt = sc::duration_cast<sc::microseconds>(tp - unix_epoch).count() * 1.0e-6;

        // Rcpp::Rcout << "tp: " << cctz::format(fmt, tp, tz) << "\n"
        //             << "unix epoch: " << cctz::format(fmt, unix_epoch, tz) << "\n"
        //             << "(tp - unix.epoch).count(): " << (tp - unix_epoch).count() << "\n"
        //             << "dt: " << dt << std::endl;

        dv(i) = Rcpp::Datetime(dt);
    }

    return dv;
}

Он просматривает входящий вектор svec строк и преобразует каждую из них.

Изменить: Вот еще один пример использования нашего пакета nanotime, который использует и использует Парсер CCTZ:

R> library(nanotime)
R> as.nanotime("2020-01-29 13:12:00.000000001 America/New_York")
[1] 2020-01-29T18:12:00.000000001+00:00
R> 

Полная точность 9 + 9 цифр с использованием базовых наносекунд с эпохи, полная совместимость с std::chrono.