How to convert unsigned int 64 into time in C++?

Question

I am converting CLI C++ code to standard C++, and i have a piece of code that gets a UINT64 number (from a remote server - so i can't change to format/precision of the time i get) and converts it into DateTime object and later outputs the following value: myDatetime.ToString("dd/MM/yyyy hh:mm:ss.fffffff tt"). I haven't found a way to convert unsigned int 64 into time in C++. The following code does nothing for numbers so big (that's the 64bit number i get from the server).

time_t rawtime=131274907755873979
localtime_s(&timeinfo, &rawtime);

I need some help :)

My question wan't answered in the thread Convert Epoch Time string to Time since it doesn't work for numbers as large as i need. For example the number 131274907755873979 which is what i get from the server. The function ctime for that value simply returns NULL. I need a way to convert between the time i get as a unsigned int64 into standard C++ time object.

Answer 1

std::string LongToString(int64_t longDate) {        
    char buff[128];

    std::chrono::duration<int64_t, std::milli> dur(longDate);
    auto tp = std::chrono::system_clock::time_point(
        std::chrono::duration_cast<std::chrono::system_clock::duration>(dur));
    std::time_t in_time_t = std::chrono::system_clock::to_time_t(tp);
    strftime(buff, 128, "%Y-%m-%d %H:%M:%S", localtime(&in_time_t));
    std::string resDate(buff);
    
    return resDate;

}

This is a case with bsoncxx::types::b_date get_date().to_int64() MongoDB.

The DateTime saved with int64_t.

Answer 2

You have not told us how the existing code converts that number into a DateTime. Let us suppose that it does so by invoking this constructor: DateTime( long long ticks ).

According to the documentation of that constructor of DateTime,

long long ticks A date and time expressed in the number of 100-nanosecond intervals that have elapsed since January 1, 0001 at 00:00:00.000 in the Gregorian calendar.

On the other hand, according to the documentation of localtime_s and the documentation of time_t, localtime_s() requires

the number of seconds (not counting leap seconds) since 00:00, Jan 1 1970 UTC.

So, you first need to convert 100-nanosecond intervals to seconds, and then convert from January 1, 0001 to January 1, 1970.

Answer 3

Using Howard Hinnant's datetime library this computation can be done quite easily. It works with VS 2013 and later.

#include "tz.h"
#include <cstdint>
#include <string>
#include <iostream>

std::string
FILETIME_to_string(std::uint64_t i)
{
    using namespace std;
    using namespace std::chrono;
    using namespace date;
    using FileTime = duration<int64_t, ratio<1, 10000000>>;
    auto const offset = sys_days{jan/1/1970} - sys_days{jan/1/1601};
    auto tp = sys_days{jan/1/1970} + (FileTime{static_cast<int64_t>(i)} - offset);
    return format("%d/%m/%Y %I:%M:%S %p", make_zoned("Etc/GMT-2", tp));
}

int
main()
{
    std::cout << FILETIME_to_string(131274907755873979) << '\n';
}

This skips DateTime and goes straight to the string. I wasn't sure what you are wanting with tt in the format. But whatever it is, it can be handled.

This library builds on the C++11 <chrono> library. So the first thing to do is to create a duration to represent the windows tick size (100 ns). Then just compute the offset between the two epochs and subtract it from the input, and form a std::chrono::time_point. Now you can format that time_point however you want.

The program above outputs:

29/12/2016 03:12:55.5873979 PM

If you use VS 2017 you'll be able to make offset constexpr, making the conversion more efficient.