[DRAFT] Added timestamp utils to mip sdk

.gitignore

@@ -6,3 +6,6 @@ int/
 .vs/
 
 src/mip/mip_version.h
+
+# Tests
+Testing/

CMakeLists.txt

@@ -99,14 +99,23 @@ configure_file(${VERSION_IN_FILE} ${VERSION_OUT_FILE})
 #
 
 set(UTILS_DIR "${MIP_DIR}/utils")
-
 set(UTILS_SOURCES
     "${UTILS_DIR}/byte_ring.c"
     "${UTILS_DIR}/byte_ring.h"
     "${UTILS_DIR}/serialization.c"
     "${UTILS_DIR}/serialization.h"
 )
 
+set(UTILS_SUBDIR_TIME "${UTILS_DIR}/time")
+set(UTILS_TIME_SOURCES
+    "${UTILS_SUBDIR_TIME}/durations.hpp"
+    "${UTILS_SUBDIR_TIME}/misc.hpp"
+    "${UTILS_SUBDIR_TIME}/standards.cpp"
+    "${UTILS_SUBDIR_TIME}/standards.hpp"
+    "${UTILS_SUBDIR_TIME}/timestamp.cpp"
+    "${UTILS_SUBDIR_TIME}/timestamp.hpp"
+)
+
 #
 # MIP Control
 #
@@ -225,6 +234,7 @@ set(ALL_MIP_SOURCES
     ${MIPDEV_SOURCES}
     ${MIP_SOURCES}
     ${UTILS_SOURCES}
+    ${UTILS_TIME_SOURCES}
     ${MIP_CPP_HEADERS}
     ${MIP_INTERFACE_SOURCES}
     ${MIP_EXTRA_SOURCES}

src/mip/utils/time/durations.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <chrono>
+#include <ratio>
+
+namespace mip
+{
+    using Nanoseconds  = std::chrono::duration<std::int64_t, std::nano>;
+    using Microseconds = std::chrono::duration<std::int64_t, std::micro>;
+    using Milliseconds = std::chrono::duration<std::int64_t, std::milli>;
+    using Seconds      = std::chrono::duration<std::int64_t>;
+    using Minutes      = std::chrono::duration<std::int32_t, std::ratio<60>>;
+    using Hours        = std::chrono::duration<std::int32_t, std::ratio<3600>>;
+    using Days         = std::chrono::duration<std::int32_t, std::ratio<86400>>;
+    using Weeks        = std::chrono::duration<std::int32_t, std::ratio<604800>>;
+    using Years        = std::chrono::duration<std::int32_t, std::ratio<31556952>>;
+}

src/mip/utils/time/misc.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "mip/utils/time/durations.hpp"
+#include "mip/utils/time/standards.hpp"
+
+namespace mip
+{
+    /// Converts time duration from one time standard to another.
+    /// 
+    /// @throws std::logic_error If time < 0 after conversion (corresponding time duration
+    ///         doesn't exist in the other standard).
+    ///
+    template<typename DurationOut = Nanoseconds, typename DurationIn>
+    DurationOut convert(DurationIn time, const TimeStandard &to, const TimeStandard &from);
+
+    /// Casts a time duration to the given arithmetic type.
+    ///
+    /// Uses a static_cast, so typical rounding rules will apply.
+    ///
+    /// @throws std::invalid_argument If time < 0 nanoseconds.
+    ///
+    template<typename T, typename DurationIn>
+    T castTime(const DurationIn &time);
+
+
+    /**************************************************************************************/
+    /* Definitions for template declarations above.                                       */
+    /**************************************************************************************/
+
+    template<typename DurationOut, typename DurationIn>
+    DurationOut convert(DurationIn time, const TimeStandard &to, const TimeStandard &from)
+    {
+        Nanoseconds converted = to.convertFromBase(from.convertToBase(std::chrono::duration_cast<Nanoseconds>(time)));
+        if (converted < Nanoseconds(0))
+        {
+            throw std::logic_error("Converted time < 0. Add exception handling with desired response!");
+        }
+
+        return std::chrono::duration_cast<DurationOut>(converted);
+
+    }
+
+    template<typename T, typename DurationIn>
+    T castTime(const DurationIn &time)
+    {
+        if (time < mip::Nanoseconds(0))
+        {
+            throw std::invalid_argument("Time < 0.");
+        }
+
+        return static_cast<T>(time.count());
+    }
+} // namespace mip

src/mip/utils/time/standards.cpp

@@ -0,0 +1,36 @@
+#include "mip/utils/time/standards.hpp"
+
+namespace mip
+{
+    Nanoseconds UnixTime::now() const
+    {
+        return std::chrono::duration_cast<Nanoseconds>(std::chrono::system_clock::now().time_since_epoch());
+    }
+
+    Nanoseconds UnixTime::convertToBase(Nanoseconds time) const
+    {
+        return time;         
+    }
+
+    Nanoseconds UnixTime::convertFromBase(Nanoseconds time) const
+    {
+        return time;      
+    }
+
+    Nanoseconds GpsTime::now() const
+    {
+        Nanoseconds now = std::chrono::duration_cast<Nanoseconds>(std::chrono::system_clock::now().time_since_epoch());
+
+        return convertFromBase(now);
+    }
+
+    Nanoseconds GpsTime::convertToBase(Nanoseconds time) const
+    {
+        return time + epoch_difference;
+    }
+
+    Nanoseconds GpsTime::convertFromBase(Nanoseconds time) const
+    {
+        return time - epoch_difference;
+    }
+}

src/mip/utils/time/standards.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "mip/utils/time/durations.hpp"
+
+namespace mip
+{
+    /// Extend this to create a new time standard.
+    struct TimeStandard
+    {
+        /// Should return the currently most up-to-date time duration in this standard.
+        virtual Nanoseconds now() const = 0;
+
+        /// Should convert the given time duration in this standard to the corresponding time in
+        /// the base standard.
+        virtual Nanoseconds convertToBase(Nanoseconds time) const = 0;
+
+        /// Should convert the given time duration in the base standard to the corresponding
+        /// time in this standard.
+        virtual Nanoseconds convertFromBase(Nanoseconds time) const = 0;
+    };
+
+    /** Common standards ****************************************************************/
+
+    struct UnixTime : TimeStandard 
+    {
+        Nanoseconds now() const override;
+        Nanoseconds convertToBase(Nanoseconds time) const override;
+        Nanoseconds convertFromBase(Nanoseconds time) const override;
+    };
+
+    struct GpsTime : TimeStandard 
+    {
+        Nanoseconds now() const override;
+        Nanoseconds convertToBase(Nanoseconds time) const override;
+        Nanoseconds convertFromBase(Nanoseconds time) const override;
+
+    private:
+        // Accounts for epoch gap and leap seconds.
+        const mip::Nanoseconds epoch_difference{Seconds(315964800 - 18)};
+    };
+} // namespace mip

src/mip/utils/time/timestamp.cpp

@@ -0,0 +1,78 @@
+#include "mip/utils/time/timestamp.hpp"
+
+#include "mip/utils/time/misc.hpp"
+
+namespace mip
+{
+    TimestampNew::TimestampNew(const mip::TimeStandard &standard) :
+        m_standard(standard)
+    {
+        synchronize();
+    }
+
+    void TimestampNew::synchronize()
+    {
+        m_timestamp = m_standard.now();
+    }
+
+    void TimestampNew::increment(const TimestampNew &reference_new, const TimestampNew &reference_old)
+    {
+        mip::Nanoseconds m_synced = reference_new.getTimestamp();
+        mip::Nanoseconds m_old = reference_old.getTimestamp();
+        if (m_synced < m_old)
+        {
+            throw std::invalid_argument("New reference timestamp < old reference timestamp.");
+        }
+
+        m_timestamp += (m_synced - m_old);
+    }
+
+    void TimestampNew::setTimestamp(Nanoseconds time)
+    {
+        if (time < Nanoseconds(0))
+        {
+            throw std::invalid_argument("Time < 0.");
+        }
+
+        m_timestamp = time;
+    }
+
+    void TimestampNew::setTimestamp(const TimestampNew &from)
+    {
+        m_timestamp = convert(from.getTimestamp(), m_standard, from.m_standard);
+    }
+
+    void TimestampNew::setWeek(Weeks week)
+    {
+        if (week < Weeks(0))         
+        {
+            throw std::invalid_argument("Week < 0.");
+        }
+
+        m_timestamp = week + getTimeOfWeek();
+    }
+
+    void TimestampNew::setTimeOfWeek(Nanoseconds time)
+    {
+        if (time < Nanoseconds(0))
+        {
+            throw std::invalid_argument("Time of week < 0.");
+        }
+        if (time >= Weeks(1))
+        {
+            throw std::invalid_argument("Time of week >= one week.");
+        }
+
+        m_timestamp = std::chrono::duration_cast<Weeks>(m_timestamp) + time;
+    }
+
+    Nanoseconds TimestampNew::getTimestamp() const
+    {
+        return m_timestamp;
+    }
+
+    Nanoseconds TimestampNew::getTimeOfWeek() const
+    {
+        return m_timestamp % Weeks(1);
+    }
+} // namespace mip