Interstellar.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef INTERSTELLAR_HPP
#define INTERSTELLAR_HPP

#include <chrono>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <duds/data/Int128.hpp>

namespace duds { namespace time { namespace interstellar {

using duds::data::int128_t;

extern const int128_t OneE6;
extern const int128_t OneE12;
extern const int128_t OneE15;

template <class Clock, class Duration>
class TimePoint : public std::chrono::time_point<Clock, Duration> {
public:
    constexpr TimePoint() = default;
    TimePoint(const TimePoint &) = default;
    template <class OtherRep, class OtherPeriod>
    constexpr TimePoint(const std::chrono::duration<OtherRep, OtherPeriod> &od) :
    std::chrono::time_point<Clock, Duration>(
        std::chrono::duration_cast<Duration, typename Duration::rep, typename Duration::period>(od)
    ) { }
    /*
     * Constructs a TimePoint from another TimePoint.
     * @param otp  The source TimePoint. It may use a different period and a
     *             a different clock type.
     */
     /*
    template <class OtherClock, class OtherDuration>
    constexpr TimePoint(const TimePoint<OtherClock, OtherDuration> &otp) :
    std::chrono::time_point<Clock, Duration>(
        std::chrono::duration_cast<Duration>(otp.time_since_epoch())
    ) { }
    */
    template <class OtherClock, class OtherDuration>
    constexpr TimePoint(const std::chrono::time_point<OtherClock, OtherDuration> &otp) :
    std::chrono::time_point<Clock, Duration>(
        std::chrono::duration_cast<Duration>(otp.time_since_epoch())
    ) { }
    TimePoint &operator=(const TimePoint &) = default;
    template <class OtherClock, class OtherDuration>
    TimePoint &operator=(const TimePoint<OtherClock, OtherDuration> &otp) {
        *this = TimePoint(otp);
        return *this;
    }
    static constexpr TimePoint min() {
        return TimePoint(Duration(
            std::numeric_limits<typename Duration::rep>::lowest()
        ) );
    }
    static constexpr TimePoint max() {
        return TimePoint(Duration(
            std::numeric_limits<typename Duration::rep>::max()
        ) );
    }
};

typedef std::chrono::duration<int128_t, std::femto> Femtoseconds;

struct FemtoClock {
    typedef Femtoseconds duration;
    typedef duration::rep rep;
    typedef duration::period period;
    typedef TimePoint<FemtoClock, duration> time_point;
    static constexpr bool is_steady = false;
    static time_point now() noexcept {
        return time_point(std::chrono::duration_cast<duration, rep, period>(
            std::chrono::system_clock::now().time_since_epoch()));
    }
};

typedef FemtoClock::time_point  FemtoTime;

typedef std::chrono::duration<std::int64_t, std::milli> Milliseconds;

struct MilliClock {
    typedef Milliseconds duration;
    typedef duration::rep rep;
    typedef duration::period period;
    typedef TimePoint<MilliClock, duration> time_point;
    static constexpr bool is_steady = false;
    static time_point now() noexcept {
        return time_point(std::chrono::duration_cast<duration>(
            std::chrono::system_clock::now().time_since_epoch()));
    }
};

typedef MilliClock::time_point  MilliTime;

typedef std::chrono::duration<std::uint64_t, std::nano> Nanoseconds;

struct NanoClock {
    typedef Nanoseconds duration;
    typedef duration::rep rep;
    typedef duration::period period;
    typedef TimePoint<NanoClock, duration> time_point;
    static constexpr bool is_steady = false;
    static time_point now() noexcept {
        return time_point(std::chrono::duration_cast<duration>(
            std::chrono::system_clock::now().time_since_epoch()));
    }
};

typedef NanoClock::time_point  NanoTime;

typedef std::chrono::duration<std::int64_t> Seconds;

struct SecondClock {
    typedef Seconds duration;
    typedef duration::rep rep;
    typedef duration::period period;
    typedef TimePoint<SecondClock, duration> time_point;
    static constexpr bool is_steady = false;
    static time_point now() noexcept {
        return time_point(std::chrono::duration_cast<duration>(
            std::chrono::system_clock::now().time_since_epoch()));
    }
};

typedef SecondClock::time_point  SecondTime;

#ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
#warning POSIX nanosecond
#else
//#warning POSIX microsecond
#endif

template <class ISTime>
boost::posix_time::ptime EarthTimeTAI(const ISTime &t) {  // ???
    return boost::posix_time::ptime((std::time_t)t.seconds());
}

} } }

#endif        //  #ifndef INTERSTELLAR_HPP