2009-10-15 6 views
12

Est-ce que quelqu'un sait s'il existe un bon moyen de transformer un boost::posix_time::ptime en une valeur __int64. (J'ai compilé la version microseconde, pas la version nanoseconde).Un moyen de transformer boost :: posix_time :: ptime en un __int64

Je dois le faire d'une certaine manière car je cherche à stocker le __int64 résultant dans un type union qui utilise les données brutes pour une application haute performance. Un certain type de fonctionnalité de Memento comme ceci serait très utile pour moi. J'aimerais éviter les jets, si possible, mais j'y aurai recours si j'en ai besoin.

+0

Eh oui, c'est ce que j'ai pensé. La documentation continue à se référer à chaque valeur intégrale comme 'longue'. Très ennuyeux, d'autant plus que l'exemple fourni montre comment calculer les secondes puisque epoch utilise la méthode qui retourne le long de –

Répondre

15

La conversion d'un ptime en nombre entier est plutôt dénuée de sens, car ptime est une abstraction du temps réel. Un temps basé sur un nombre entier est une représentation de ce temps en tant que comptage d'une époque. Ce que vous (probablement) voulez faire est de générer un time_duration de votre temps à l'époque qui vous intéresse, puis utilisez le time_duration :: ticks() pour obtenir l'entier de 64 bits. Vous pourriez avoir à l'échelle de votre résultat à votre précision désirée:

ptime myEpoch(date(1970,Jan,1)); // Or whatever your epocj is. 
time_duration myTimeFromEpoch = myTime - myEpoch; 
boost::int64_t myTimeAsInt = myTimeFromEpoch.ticks(); 
+0

Ahah ... Je suppose que j'avais raté que je pourrais soustraire un time_duration. Merci, cela aide énormément. –

0

Cela est facile à faire en utilisant les classes chrono C++ 0x, qui sont basées sur une version simplifiée de la bibliothèque heure/date de Boost, mais en regardant les documents Boost, je ne vois rien de particulièrement évident. En fait, la seule façon de le faire, je peux voir est d'appeler to_tm pour le convertir en un standard C struct tm, puis multiplier les champs ensemble. C'est un peu méchant, mais devrait fonctionner (même si vous voulez faire attention aux secondes intercalaires et autres).

+1

Malheureusement, j'ai aussi besoin de conserver la résolution de la microseconde, donc ça ne marchera pas. Je vois un from_ftime. Dommage, il n'y a pas de to_ftime. Cela rendrait les choses plus faciles. –

0
#include <boost/date_time/posix_time/posix_time.hpp> 

// ... 

uint64_t secondsSinceEpoch(const boost::posix_time::ptime& time) { 
    namespace bpt = boost::posix_time; 
    const bpt::ptime epoch = bpt::from_time_t(0); 
    bpt::time_duration duration = time - epoch; 
    return duration.total_seconds(); 
} 

// ... 

namespace bpt = boost::posix_time; 
const bpt::ptime now = bpt::second_clock::local_time(); 
uint64_t seconds = secondsSinceEpoch(now); 
std::cout << "seconds: " << seconds << std::endl; 
Questions connexes