X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FScheduler%2FClockService.hh;h=cc859afb551e669c1111b4683ec3976ef2f3b59e;hb=78a6e233083efa63a9cd0684a92abc64202a9ee7;hp=8fb1341a12d8d56bd24d20c7a205135b782dcbc8;hpb=601d1f509f5bb24df167a4dd5a20da67a0af9af8;p=senf.git

diff --git a/senf/Scheduler/ClockService.hh b/senf/Scheduler/ClockService.hh
index 8fb1341..cc859af 100644
--- a/senf/Scheduler/ClockService.hh
+++ b/senf/Scheduler/ClockService.hh
@@ -27,14 +27,14 @@
 #define HH_SENF_Scheduler_ClockService_ 1
 
 // Custom includes
-#include <sys/time.h> 
+#include <sys/time.h>
 #include <boost/utility.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <boost/cstdint.hpp>
-#include "../config.hh"
-#include "../Utils/singleton.hh"
-#include "../Utils/Console/Parse.hh"
+#include <senf/config.hh>
+#include <senf/Utils/singleton.hh>
+#include <senf/Utils/Console/Parse.hh>
 
 //#include "ClockService.mpp"
 ///////////////////////////////hh.p////////////////////////////////////////
@@ -46,12 +46,12 @@ namespace senf {
 #endif
 
     // Implementation note: The clock value is represented as a 64bit unsigned integer number of
-    // nanosecods based on the CLOCK_MONOTONIC POSIX clock.
+    // nanoseconds based on the CLOCK_MONOTONIC POSIX clock.
     //
     // To allow conversion between clock value and absolute time, the ClockService samples the
     // absolute current time and the clock value when the conversion is performed. This is done at
     // most once per second on a if-needed basis.
-    
+
     /** \brief Reliable high precision monotonous clock source
 
         The ClockService provides a highly accurate monotonous clock source based on
@@ -59,7 +59,7 @@ namespace senf {
 
         \implementation The funny mixture of static and non-static members stems from the old
             implementation based on interval timers and gettimeofday(). The current implementation
-            usses POSIX clocks and is much simpler and more precise.
+            uses POSIX clocks and is much simpler and more precise.
       */
     class ClockService
         : singleton<ClockService>
@@ -69,7 +69,7 @@ namespace senf {
         // Types
 
         /** \brief ClockService timer data type
-            
+
             Unsigned integer type representing scheduler time. Scheduler time is measured in
             nanoseconds relative to some implementation defined reference time.
          */
@@ -83,23 +83,26 @@ namespace senf {
 
         /** \brief Absolute time data type
 
-            Boost.DateTime datatype used to represent absolute date/time values.
+            <a href="http://www.boost.org/doc/libs/release/libs/date_time/index.html">Boost.DateTime</a>
+            datatype used to represent absolute date/time values.
          */
         typedef boost::posix_time::ptime abstime_type;
 
         /** \brief Relative time data type
 
-            Boost.DateTime datatype used to represent time intervals
+            <a href="http://www.boost.org/doc/libs/release/libs/date_time/index.html">Boost.DateTime</a>
+            datatype used to represent time intervals
          */
         typedef boost::posix_time::time_duration reltime_type;
 
         ///////////////////////////////////////////////////////////////////////////
 
         static clock_type now();  ///< Return current clock value
-        
+
         static abstime_type abstime(clock_type clock); ///< Convert clock to absolute time
                                         /**< This member converts a clock value into an absolute
-                                             Boost.DateTime value.
+                                             <a href="http://www.boost.org/doc/libs/release/libs/date_time/index.html">Boost.DateTime</a>
+                                             value.
                                              \note You should not base timeout calculations on this
                                                  absolute time value. Clock time is guaranteed to be
                                                  monotonous, absolute time may be non-monotonous if
@@ -107,21 +110,22 @@ namespace senf {
 
         static reltime_type reltime(clock_type clock); ///< Convert clock to relative time
                                         /**< This member converts a clock value into a relative
-                                             Boost.DateTime time interval
+                                             <a href="http://www.boost.org/doc/libs/release/libs/date_time/index.html">Boost.DateTime</a>
+                                             time interval
                                              \note The resolution of reltime_type might be smaller
                                                  than the clock_type resolution */
 
         static clock_type clock(abstime_type time); ///< Convert absolute time to clock value
-                                        /**< This member converst an absolute time value into the
+                                        /**< This member convert an absolute time value into the
                                              corresponding clock value.
                                              \see abstime */
 
-        static clock_type from_time_t(time_t const & time); 
+        static clock_type from_time_t(time_t const & time);
                                         ///< Convert legacy time_t to clock value
-                                        /**< This member converts an absolute time value 
+                                        /**< This member converts an absolute time value
                                              represented as a time_t value into a clock value */
 
-        static clock_type from_timeval(timeval const & time); 
+        static clock_type from_timeval(timeval const & time);
                                         ///< Convert legacy timeval to clock value
                                         /**< This member converts an absolute time value
                                              represented as a timeval value into a clock value */
@@ -142,7 +146,7 @@ namespace senf {
         static int64_type in_hours(clock_type v); ///< Convert \a v to hours
         static int64_type in_days(clock_type v); ///< Convert \a v to days
 
-        static void restart(); ///< Force re-syncronisation of abstime and clock
+        static void restart(); ///< Force re-synchronization of abstime and clock
                                         /**< Calling the member should never be necessary since
                                              abstime() / clock() automatically call restart() if
                                              needed */
@@ -197,7 +201,7 @@ namespace senf {
         <tr><td><code>2md</code></td><td>(very unusual) 2 milli-days</td></tr>
         </table>
      */
-    void parseClockServiceInterval(console::ParseCommandInfo::TokensRange const & tokens, 
+    void parseClockServiceInterval(console::ParseCommandInfo::TokensRange const & tokens,
                                    ClockService::clock_type & out);
 
     void formatClockServiceInterval(ClockService::clock_type interval, std::ostream & os);