Come convertire un timestamp di epoca epocale (doppio) in uno std :: chrono :: time_point?

Question

Ho un timestamp in epoca frazionaria, rappresentato come double, che vorrei convertire in un appropriato std::chrono::time_point. L'epoca è la solita epoca UNIX dall'1/1/1970. So che esiste std::chrono::system_clock::from_time_t, ma uno time_t non ha una parte frazionaria. Quale sarebbe il modo migliore per farlo con C++ 11 significa?

Questa domanda è relativa a unix timestamp to boost::posix_time::ptime, tranne che richiede il C++ 11 anziché la versione Boost.

Answer 1

Supponendo che l'epoca sia la stessa di un tipo noto clock, è possibile utilizzare una durata con una rappresentazione double e convertirla nella durata utilizzata da tale orologio.

// change period to appropriate units - I'm assuming seconds 
typedef std::chrono::duration<double, std::ratio<1>> d_seconds; 

d_seconds since_epoch_full(324324.342); 
auto since_epoch = std::chrono::duration_cast<clock::duration>(since_epoch_full); 
clock::time_point point(since_epoch); 

Questo dovrebbe essere ok per qualsiasi calcolo che coinvolge che l'orologio, dal momento che si sta utilizzando la stessa precisione come l'orologio, ma può perdere un po 'della precisione nella conversione. Se non vuoi perdere, dovrai utilizzare una specializzazione time_point che utilizza il tipo di durata basato su double. E poi usalo nei tuoi calcoli (ovviamente, con tutti gli avvertimenti della matematica in virgola mobile).

typedef std::chrono::time_point<clock, d_seconds> d_time_point; 

Tuttavia, questo complica i calcoli coinvolgono stesso orologio, in quanto richiede conversioni. Per facilitare questa operazione, è possibile costruire il proprio involucro orologio che fa le conversioni e l'uso che:

template <typename Clock> 
struct my_clock_with_doubles { 
    typedef double rep; 
    typedef std::ratio<1> period; 
    typedef std::chrono::duration<rep, period> duration; 
    typedef std::chrono::time_point<my_clock_with_doubles<Clock>> time_point; 
    static const bool is_steady = Clock::is_steady; 

    static time_point now() noexcept { 
     return time_point(std::chrono::duration_cast<duration>(
        Clock::now().time_since_epoch() 
       )); 
    } 

    static time_t to_time_t(const time_point& t) noexcept { 
     return Clock::to_time_t(typename Clock::time_point(
          std::chrono::duration_cast<typename Clock::duration>(
           t.time_since_epoch() 
          ) 
         )); 
    } 
    static time_point from_time_t(time_t t) noexcept { 
     return time_point(std::chrono::duration_cast<duration>(
        Clock::from_time_t(t).time_since_epoch() 
       )); 
    } 
};