date_time.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_TOOLS_DATE_TIME_H_
#define GENESIS_UTILS_TOOLS_DATE_TIME_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2020 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@h-its.org>
    Exelixis Lab, Heidelberg Institute for Theoretical Studies
    Schloss-Wolfsbrunnenweg 35, D-69118 Heidelberg, Germany
*/
 
#include <ctime>
#include <string>
#include <vector>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Convenience Functions
// =================================================================================================
 
std::string current_date();
 
std::string current_time();
 
std::time_t tm_to_time( std::tm time, bool use_local_time = false );
 
std::vector<std::time_t> tm_to_time( std::vector<std::tm> const& times, bool use_local_time = false );
 
template<typename ForwardIterator>
std::vector<std::time_t> tm_to_time(
    ForwardIterator first,
    ForwardIterator last,
    bool use_local_time = false,
    size_t size = 0
) {
    // Prep.
    std::vector<std::time_t> ret;
    ret.reserve( size );
 
    // Add all values. Throws on error.
    while( first != last ) {
        ret.push_back( tm_to_time( *first, use_local_time ));
        ++first;
    }
    return ret;
}
 
std::tm time_to_tm( std::time_t const& time, bool use_local_time = false );
 
std::vector<std::tm> time_to_tm( std::vector<std::time_t> const& times, bool use_local_time = false );
 
template<typename ForwardIterator>
std::vector<std::tm> time_to_tm(
    ForwardIterator first,
    ForwardIterator last,
    bool use_local_time = false,
    size_t size = 0
) {
    // Prep.
    std::vector<std::tm> ret;
    ret.reserve( size );
 
    // Add all values. Throws on error.
    while( first != last ) {
        ret.push_back( time_to_tm( *first, use_local_time ));
        ++first;
    }
    return ret;
}
 
// =================================================================================================
//     Date/Time Conversion from std::tm
// =================================================================================================
 
std::string tm_to_string( std::tm const& time, std::string const& format, std::string const& locale );
 
std::string tm_to_string( std::tm const& time, std::string const& format );
 
std::string tm_to_string( std::tm const& time );
 
std::string tm_date_to_string( std::tm const& time );
 
std::string tm_time_to_string( std::tm const& time );
 
// =================================================================================================
//     Date/Time Conversion to std::tm
// =================================================================================================
 
std::tm convert_to_tm( std::string const& str, std::string const& format, std::string const& locale );
 
std::tm convert_to_tm( std::string const& str, std::string const& format );
 
std::tm convert_to_tm( std::string const& str );
 
template<typename ForwardIterator>
std::vector<std::tm> convert_to_tm(
    ForwardIterator first,
    ForwardIterator last,
    std::string const& format,
    std::string const& locale,
    size_t size = 0
) {
    // Prep.
    std::vector<std::tm> ret;
    ret.reserve( size );
 
    // Add all values. Throws on error.
    while( first != last ) {
        ret.push_back( convert_to_tm( *first, format, locale ));
        ++first;
    }
    return ret;
}
 
template<typename ForwardIterator>
std::vector<std::tm> convert_to_tm(
    ForwardIterator first,
    ForwardIterator last,
    std::string const& format,
    size_t size = 0
) {
    // Prep.
    std::vector<std::tm> ret;
    ret.reserve( size );
 
    // Add all values. Throws on error.
    while( first != last ) {
        ret.push_back( convert_to_tm( *first, format ));
        ++first;
    }
    return ret;
}
 
template<typename ForwardIterator>
std::vector<std::tm> convert_to_tm(
    ForwardIterator first,
    ForwardIterator last,
    size_t size = 0
) {
    // Prep.
    std::vector<std::tm> ret;
    ret.reserve( size );
 
    // Add all values. Throws on error.
    while( first != last ) {
        ret.push_back( convert_to_tm( *first ));
        ++first;
    }
    return ret;
}
 
bool is_convertible_to_tm( std::string const& str, std::string const& format, std::string const& locale );
 
bool is_convertible_to_tm( std::string const& str, std::string const& format );
 
bool is_convertible_to_tm( std::string const& str );
 
template<typename ForwardIterator>
bool is_convertible_to_tm(
    ForwardIterator first,
    ForwardIterator last,
    std::string const& format,
    std::string const& locale
) {
    // If one of the conversions fails, the list is not convertible.
    while( first != last ) {
        if( ! is_convertible_to_tm( *first, format, locale )) {
            return false;
        }
        ++first;
    }
    return true;
}
 
template<typename ForwardIterator>
bool is_convertible_to_tm(
    ForwardIterator first,
    ForwardIterator last,
    std::string const& format
) {
    // If one of the conversions fails, the list is not convertible.
    while( first != last ) {
        if( ! is_convertible_to_tm( *first, format )) {
            return false;
        }
        ++first;
    }
    return true;
}
 
template<typename ForwardIterator>
bool is_convertible_to_tm(
    ForwardIterator first,
    ForwardIterator last
) {
    // If one of the conversions fails, the list is not convertible.
    while( first != last ) {
        if( ! is_convertible_to_tm( *first )) {
            return false;
        }
        ++first;
    }
    return true;
}
 
} // namespace utils
} // namespace genesis
 
#endif // include guard