Comment analyser la date/heure d'une chaîne?

Question

Entrée: chaînes avec date et heure optionnelle. Différentes représentations seraient bien mais nécessaires. Les chaînes sont fournies par l'utilisateur et peuvent être malformées. Exemples:

• "2004-03-21 12:45:33" (je considère ce la mise en page par défaut)
• "2004/03/21 12:45:33" (mise en page en option)
• "23.09.2004 04:12:21" (format allemand, en option)
• "2003-02-11" (temps peut manquer)

Sortie nécessaire: secondes depuis l'époque (1970/01/01 00:00:00) ou un autre point fixe.

Bonus: De plus, lire le décalage UTC de l'heure système locale serait super.

L'entrée est supposée être une heure locale sur la machine en question. La sortie doit être UTC. Le système est Linux seulement (Debian Lenny et Ubuntu sont nécessaires).

J'ai essayé d'utiliser boost/date_time, mais je dois admettre que je ne peux pas faire le tour de la documentation. Les travaux suivants sans la conversion nécessaire de l'heure locale du système à UTC:

std::string date = "2000-01-01"; 
boost::posix_time::ptime ptimedate = boost::posix_time::time_from_string(date); 
ptimedate += boost::posix_time::hours(Hardcoded_UTC_Offset);// where to get from? 
struct tm = boost::posix_time::to_tm(ptimedate); 
int64_t ticks = mktime(&mTmTime); 

Je pense que boost::date_time peut fournir l'UTC nécessaire décalage, mais je ne sais pas comment.

Answer 1

Bien que je ne sache pas comment formater une entrée de mois à un chiffre en boost, je peux le faire après le montage à deux chiffres:

#include <iostream> 
#include <boost/date_time.hpp> 
namespace bt = boost::posix_time; 
const std::locale formats[] = { 
std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d %H:%M:%S")), 
std::locale(std::locale::classic(),new bt::time_input_facet("%Y/%m/%d %H:%M:%S")), 
std::locale(std::locale::classic(),new bt::time_input_facet("%d.%m.%Y %H:%M:%S")), 
std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d"))}; 
const size_t formats_n = sizeof(formats)/sizeof(formats[0]); 

std::time_t pt_to_time_t(const bt::ptime& pt) 
{ 
    bt::ptime timet_start(boost::gregorian::date(1970,1,1)); 
    bt::time_duration diff = pt - timet_start; 
    return diff.ticks()/bt::time_duration::rep_type::ticks_per_second; 

} 
void seconds_from_epoch(const std::string& s) 
{ 
    bt::ptime pt; 
    for(size_t i=0; i<formats_n; ++i) 
    { 
     std::istringstream is(s); 
     is.imbue(formats[i]); 
     is >> pt; 
     if(pt != bt::ptime()) break; 
    } 
    std::cout << " ptime is " << pt << '\n'; 
    std::cout << " seconds from epoch are " << pt_to_time_t(pt) << '\n'; 
} 
int main() 
{ 
    seconds_from_epoch("2004-03-21 12:45:33"); 
    seconds_from_epoch("2004/03/21 12:45:33"); 
    seconds_from_epoch("23.09.2004 04:12:21"); 
    seconds_from_epoch("2003-02-11"); 
} 

Notez que la sortie des secondes de-époque sera acquis que la date était en UTC:

~ $ ./test | head -2 
ptime is 2004-Mar-21 12:45:33 
seconds from epoch are 1079873133 
~ $ date -d @1079873133 
Sun Mar 21 07:45:33 EST 2004 

Vous pouvez probablement utiliser boost::posix_time::c_time::localtime() de #include <boost/date_time/c_time.hpp> pour obtenir cette conversion fait en supposant que l'entrée est dans le fuseau horaire actuel, mais il est plutôt incohérent: pour moi, par exemple, le résultat sera différent entre aujourd'hui et le mois prochain, lorsque l'heure d'été se terminera.

Answer 2

la plus simple, la solution portable est d'utiliser scanf:

int year, month, day, hour, minute, second = 0; 
int r = 0; 

r = scanf ("%d-%d-%d %d:%d:%d", &year, &month, &day, 
      &hour, &minute, &second); 
if (r == 6) 
{ 
    printf ("%d-%d-%d %d:%d:%d\n", year, month, day, hour, minute, 
      second); 
} 
else 
{ 
    r = scanf ("%d/%d/%d %d:%d:%d", &year, &month, &day, 
      &hour, &minute, &second); 
    // and so on ... 

Initialiser une struct tm avec les int valeurs et passer à mktime pour obtenir un temps de calendrier comme time_t. Pour les conversions de fuseau horaire, veuillez see information sur gmtime.

Answer 3

boost::gregorian a quelques-unes des choses que vous avez besoin sans vous faire plus de travail:

using namespace boost::gregorian; 
{ 
    // The following date is in ISO 8601 extended format (CCYY-MM-DD) 
    std::string s("2000-01-01"); 
    date d(from_simple_string(s)); 
    std::cout << to_simple_string(d) << std::endl; 
} 

Il y a un exemple sur la façon d'utiliser UTC compense avec boost::posix_timehere.

Vous pouvez fournir la génération de la date et de l'heure à partir des formats de chaîne d'entrée personnalisés à l'aide des formats date_input_facet et time_input_facet. Il y a un tutoriel d'E/S sur this page qui devrait vous aider à démarrer.

Answer 4

Si c-style est acceptable: strptime() est le chemin à parcourir, parce que vous pouvez spécifier le format et il peut prendre locale compte:

tm brokenTime; 
strptime(str.c_str(), "%Y-%m-%d %T", &brokenTime); 
time_t sinceEpoch = timegm(brokenTime); 

mises en page différentes devront vérifier la valeur de retour (si possible). Le fuseau horaire devra être ajouté à en vérifiant l'horloge du système (localtime_r() avec time(), tm_zone)