TimePoint.hpp

Go to the documentation of this file.

#ifndef FOCS_TIMEPOINT
#define FOCS_TIMEPOINT
 
#include <cmath>
#include <string>
 
#include "focs/LeapSecondDatabase.hpp"
 
#include <boost/date_time/gregorian_calendar.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
 
namespace focs {
    class TimePoint {
        public:
            enum class ClockType {
                local, 
                utc,   
                tai,   
                tai93, 
                gps,   
                tt     
            };
 
            explicit TimePoint() : ptime_{boost::posix_time::microsec_clock::universal_time()} {};
 
            TimePoint(const double seconds_since_epoch, const TimePoint::ClockType clock_type=ClockType::utc);
 
            TimePoint(const boost::gregorian::date& date, const boost::posix_time::time_duration& time) : ptime_{date, time} {}
 
            TimePoint(const boost::gregorian::date date, const boost::posix_time::time_duration& time, const int milli) : ptime_{date, time + boost::posix_time::milliseconds{milli}} {}
 
            explicit TimePoint(const boost::posix_time::ptime& ptime) : ptime_{ptime} {}
 
            explicit TimePoint(const std::string& datetime);
 
            // TimePoint(const TimePoint& other){ptime_ = other.ptime_; clock_type_ = other.clock_type_;}
 
            const std::string to_string(const std::string &format="%Y-%m-%dT%H:%M:%S%F") const;
 
            const boost::posix_time::ptime& native() const {return ptime_;} // shouldn't be relied on, but I won't wrap everything
 
            inline friend std::ostream& operator<<(std::ostream &out, const TimePoint& t){return out << t.to_string();}
 
            // boost::posix_time::time_duration duration_since(const boost::posix_time::ptime& time) const;
 
            // /*! \brief Return duration since 1970-01-01 00:00:00.
            //     \return duration since 1970-01-01 00:00:00.  */
            // boost::posix_time::time_duration duration_since_1970() const {return duration_since(boost::posix_time::ptime{{1970,1,1}});}
            // /*! \brief Return seconds since 1970-01-01 00:00:00.
            //     \return seconds since 1970-01-01 00:00:00.  */
            // double seconds_since_1970() const {return (double)duration_since_1970().total_microseconds() / 1'000'000.0;}
            // /*! \brief Return duration since 1993-01-01 00:00:00.  
            //     \return duration since 1993-01-01 00:00:00.  */
            // boost::posix_time::time_duration duration_since_1993() const {return duration_since(boost::posix_time::ptime{{1993,1,1}});}
            // /*! \brief Return seconds since 1993-01-01 00:00:00.  
            //     \return seconds since 1993-01-01 00:00:00.  */
            // double seconds_since_1993() const {return (double)duration_since_1993().total_microseconds() / 1'000'000.0;}
            // /*! \brief Return duration since 1958-01-01 00:00:00.  
            //     \return duration since 1958-01-01 00:00:00.  */
            // boost::posix_time::time_duration duration_since_1958() const {return duration_since(boost::posix_time::ptime{{1958,1,1}});}
            // /*! \brief Return seconds since 1958-01-01 00:00:00.  
            //     \return seconds since 1958-01-01 00:00:00.  */
            // double seconds_since_1958() const {return (double)duration_since_1958().total_microseconds() / 1'000'000.0;}
 
            double seconds_since(const TimePoint::ClockType clock_type) const;
 
            double utc() const { return seconds_since(ClockType::utc); }
 
            double tai() const { return seconds_since(ClockType::tai); }
 
            double tai93() const { return seconds_since(ClockType::tai93); }
 
            double gps() const { return seconds_since(ClockType::gps); }
 
            double tt() const { return seconds_since(ClockType::tt); }
 
 
            // Developer note for the following Julian functions: This is
            // re-implementing ptime's julian_date(), which returns a long,
            // losing fractional seconds.
 
            double julian_date() const {return (utc() / 86400.0) + 2440587.5;}
            double modified_julian_date() const {return julian_date() - 2400000.5;}
            double reduced_julian_date() const {return julian_date() - 2400000.0;}
            double truncated_julian_date() const {return std::floor(julian_date() - 2440000.5);}
 
            friend inline bool operator==(const TimePoint& lhs, const TimePoint& rhs){
                return lhs.ptime_ == rhs.ptime_;
            }
            friend inline bool operator!=(const TimePoint& lhs, const TimePoint& rhs){ return !(lhs == rhs); }
 
            friend inline bool operator<(const TimePoint& lhs, const TimePoint& rhs){
                return lhs.ptime_ < rhs.ptime_;
            }
 
            friend inline bool operator> (const TimePoint& lhs, const TimePoint& rhs){ return rhs < lhs; }
 
            friend inline bool operator<=(const TimePoint& lhs, const TimePoint& rhs){ return !(lhs > rhs); }
 
            friend inline bool operator>=(const TimePoint& lhs, const TimePoint& rhs){ return !(lhs < rhs); }
 
 
            // ************************************************************************************
            // Start simple boost::posix_time wrappers
 
            int16_t year() const {return static_cast<int16_t>(ptime_.date().year());}
 
            uint8_t month() const {return static_cast<uint8_t>(ptime_.date().month());}
 
            uint8_t day() const {return static_cast<uint8_t>(ptime_.date().day());}
 
            uint16_t day_of_year() const {return static_cast<uint8_t>(ptime_.date().day_of_year());}
 
            uint8_t hour() const {return static_cast<uint8_t>(ptime_.time_of_day().hours());}
 
            uint8_t minute() const {return static_cast<uint8_t>(ptime_.time_of_day().minutes());}
 
            uint8_t second() const {return static_cast<uint8_t>(ptime_.time_of_day().seconds());}
 
            // End simple boost::posix_time wrappers
            // ************************************************************************************
        private:
            boost::posix_time::ptime ptime_;
    };
} // namespace focs
 
#endif // FOCS_TIMEPOINT