uhd: reworked time_spec_t to be more flexible: arithmetic, comparison operators...

Replaced nsecs with fractional seconds in units of seconds.
Replaced nsecs and secs members with public function members.
time_spec_t has a more diverse set of constructors and methods.
It can handle the cases where frac secs are greater than 1 second.

1 files changed, 47 insertions, 35 deletions

diff --git a/host/include/uhd/types/time_spec.hpp b/host/include/uhd/types/time_spec.hpp
index 7353c6e25..59b85f4b7 100644
--- a/host/include/uhd/types/time_spec.hpp
+++ b/host/include/uhd/types/time_spec.hpp
@@ -19,68 +19,75 @@
 #define INCLUDED_UHD_TYPES_TIME_SPEC_HPP
 
 #include <uhd/config.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/operators.hpp>
+#include <ctime>
 
 namespace uhd{
 
     /*!
-     * A time_spec_t holds a seconds and fractional seconds time value.
-     * The time_spec_t can be used when setting the time on devices,
-     * and for dealing with time stamped samples though the metadata.
-     * and for controlling the start of streaming for applicable dsps.
+     * A time_spec_t holds a seconds and a fractional seconds time value.
+     * Depending upon usage, the time_spec_t can represent absolute times,
+     * relative times, or time differences (between absolute times).
      *
-     * The fractional seconds are represented in units of nanoseconds,
-     * which provide a clock-domain independent unit of time storage.
-     * The methods "get_ticks" and "set_ticks" can be used to convert
-     * the fractional seconds to and from clock-domain specific units.
+     * The time_spec_t provides clock-domain independent time storage,
+     * but can convert fractional seconds to/from clock-domain specific units.
      *
-     * The nanoseconds count is stored as double precision floating point.
+     * The fractional seconds are stored as double precision floating point.
      * This gives the fractional seconds enough precision to unambiguously
      * specify a clock-tick/sample-count up to rates of several petahertz.
      */
-    struct UHD_API time_spec_t:
-        boost::addable<time_spec_t>,
-        boost::subtractable<time_spec_t>,
-        boost::equality_comparable<time_spec_t>{
+    class UHD_API time_spec_t : boost::additive<time_spec_t>, boost::totally_ordered<time_spec_t>{
+    public:
 
-        //! whole/integer seconds count in seconds
-        boost::uint32_t secs;
+        /*!
+         * Create a time_spec_t from a real-valued seconds count.
+         * \param secs the real-valued seconds count (default = 0)
+         */
+        time_spec_t(double secs = 0);
 
-        //! fractional seconds count in nano-seconds
-        double nsecs;
+        /*!
+         * Create a time_spec_t from whole and fractional seconds.
+         * \param full_secs the whole/integer seconds count
+         * \param frac_secs the fractional seconds count (default = 0)
+         */
+        time_spec_t(time_t full_secs, double frac_secs = 0);
+
+        /*!
+         * Create a time_spec_t from whole and fractional seconds.
+         * Translation from clock-domain specific units.
+         * \param full_secs the whole/integer seconds count
+         * \param tick_count the fractional seconds tick count
+         * \param tick_rate the number of ticks per second
+         */
+        time_spec_t(time_t full_secs, size_t tick_count, double tick_rate);
 
         /*!
-         * Convert the fractional nsecs to clock ticks.
+         * Convert the fractional seconds to clock ticks.
          * Translation into clock-domain specific units.
          * \param tick_rate the number of ticks per second
          * \return the fractional seconds tick count
          */
-        boost::uint32_t get_ticks(double tick_rate) const;
+        size_t get_tick_count(double tick_rate) const;
 
         /*!
-         * Set the fractional nsecs from clock ticks.
-         * Translation from clock-domain specific units.
-         * \param ticks the fractional seconds tick count
-         * \param tick_rate the number of ticks per second
+         * Get the time as a real-valued seconds count.
+         * Note: If this time_spec_t represents an absolute time,
+         * the precision of the fractional seconds may be lost.
+         * \return the real-valued seconds
          */
-        void set_ticks(boost::uint32_t ticks, double tick_rate);
+        double get_real_secs(void) const;
 
         /*!
-         * Create a time_spec_t from whole and fractional seconds.
-         * \param secs the whole/integer seconds count in seconds (default = 0)
-         * \param nsecs the fractional seconds count in nanoseconds (default = 0)
+         * Get the whole/integer part of the time in seconds.
+         * \return the whole/integer seconds
          */
-        time_spec_t(boost::uint32_t secs = 0, double nsecs = 0);
+        time_t get_full_secs(void) const;
 
         /*!
-         * Create a time_spec_t from whole and fractional seconds.
-         * Translation from clock-domain specific units.
-         * \param secs the whole/integer seconds count in seconds
-         * \param ticks the fractional seconds tick count
-         * \param tick_rate the number of ticks per second
+         * Get the fractional part of the time in seconds.
+         * \return the fractional seconds
          */
-        time_spec_t(boost::uint32_t secs, boost::uint32_t ticks, double tick_rate);
+        double get_frac_secs(void) const;
 
         //! Implement addable interface
         time_spec_t &operator+=(const time_spec_t &);
@@ -88,11 +95,16 @@ namespace uhd{
         //! Implement subtractable interface
         time_spec_t &operator-=(const time_spec_t &);
 
+    //private time storage details
+    private: time_t _full_secs; double _frac_secs;
     };
 
     //! Implement equality_comparable interface
     UHD_API bool operator==(const time_spec_t &, const time_spec_t &);
 
+    //! Implement less_than_comparable interface
+    UHD_API bool operator<(const time_spec_t &, const time_spec_t &);
+
 } //namespace uhd
 
 #endif /* INCLUDED_UHD_TYPES_TIME_SPEC_HPP */