Changes in src/libcfa/time [07b8001:8ad6533]

File:

• src/libcfa/time (modified) (7 diffs)

src/libcfa/time

@@ -10 +10 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 13 07:51:52 2018
-// Update Count     : 634
+// Last Modified On : Mon Apr  9 13:10:23 2018
+// Update Count     : 616
 // 
 
@@ -23 +23 @@
 #include <sys/time.h>                                                                   // timeval
 }
-#include <time_t.h>                                                                             // Duration/Time types
+#include <iostream>                                                                             // istype/ostype
 
 enum { TIMEGRAN = 1_000_000_000LL };                                    // nanosecond granularity, except for timeval
@@ -30 +30 @@
 //######################### Duration #########################
 
+struct Duration {                                                                               // private
+        int64_t tv;                                                                                     // nanoseconds
+}; // Duration
+
+static inline void ?{}( Duration & dur ) with( dur ) { tv = 0; }
 static inline void ?{}( Duration & dur, Duration d ) with( dur ) { tv = d.tv; }
 
+static inline void ?{}( Duration & dur, zero_t ) with( dur ) { tv = 0; }
 static inline Duration ?=?( Duration & dur, zero_t ) { return dur{ 0 }; }
 
@@ -69 +75 @@
 
 static inline Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
+
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
 
 static inline Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
@@ -135 +143 @@
 
 
+//######################### C time #########################
+
+static inline char * ctime( time_t tp ) { char * buf = ctime( &tp ); buf[24] = '\0'; return buf; }
+static inline char * ctime_r( time_t tp, char * buf ) { ctime_r( &tp, buf ); buf[24] = '\0'; return buf; }
+static inline tm * gmtime( time_t tp ) { return gmtime( &tp ); }
+static inline tm * gmtime_r( time_t tp, tm * result ) { return gmtime_r( &tp, result ); }
+static inline tm * localtime( time_t tp ) { return localtime( &tp ); }
+static inline tm * localtime_r( time_t tp, tm * result ) { return localtime_r( &tp, result ); }
+
+
 //######################### Time #########################
 
-static inline void ?{}( Time & time, Time t ) with( time ) { tv = t.tv; }
-void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
-static inline void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
-
-static inline Time ?=?( Time & time, zero_t ) { return time{ 0 }; }
+struct Time {                                                                                   // private
+        uint64_t tv;                                                                            // nanoseconds since UNIX epoch
+}; // Time
+
+static inline void ?{}( Time & t ) with( t ) { tv = 0; } // fast
+void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 ); // slow
+
+static inline void ?{}( Time & t, zero_t ) { t.tv = 0; }
+static inline Time ?=?( Time & t, zero_t ) { return t{ 0 }; }
+
+static inline void ?{}( Time & time, timeval t ) with( time ) {
+        tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000;
+} // Time
 
 static inline Time ?=?( Time & time, timeval t ) with( time ) {
@@ -188 +214 @@
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
 
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+
 //------------------------- timeval (cont) -------------------------
 
@@ -202 +230 @@
 } // ?{}
 
+
+//######################### Clock #########################
+
+struct Clock {                                                                                  // private
+        Duration offset;                                                                        // for virtual clock: contains offset from real-time
+        int clocktype;                                                                          // implementation only -1 (virtual), CLOCK_REALTIME
+};
+
+static inline void resetClock( Clock & clk ) with( clk ) {
+        clocktype = CLOCK_REALTIME_COARSE;
+} // Clock::resetClock
+
+static inline void resetClock( Clock & clk, Duration adj ) with( clk ) {
+        clocktype = -1;
+        offset = adj + timezone`s;                                                      // timezone (global) is (UTC - local time) in seconds
+} // resetClock
+
+static inline void ?{}( Clock & clk ) {
+        resetClock( clk );
+} // Clock
+
+static inline void ?{}( Clock & clk, Duration adj ) {
+        resetClock( clk, adj );
+} // Clock
+
+static inline Duration getRes() {
+        struct timespec res;
+        clock_getres( CLOCK_REALTIME_COARSE, &res );
+        return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
+} // getRes
+
+static inline Time getTimeNsec() {                                              // with nanoseconds
+        timespec curr;
+        clock_gettime( CLOCK_REALTIME_COARSE, &curr );
+        return (Time){ curr };
+} // getTime
+
+static inline Time getTime() {                                                  // without nanoseconds
+        timespec curr;
+        clock_gettime( CLOCK_REALTIME_COARSE, &curr );
+        curr.tv_nsec = 0;
+        return (Time){ curr };
+} // getTime
+
+static inline Time getTime( Clock & clk ) with( clk ) {
+        return getTime() + offset;
+} // getTime
+
+static inline Time ?()( Clock & clk ) with( clk ) {             // alternative syntax
+        return getTime() + offset;
+} // getTime
+
+static inline timeval getTime( Clock & clk ) {
+        return (timeval){ clk() };
+} // getTime
+
+static inline tm getTime( Clock & clk ) with( clk ) {
+        tm ret;
+        localtime_r( getTime( clk ).tv_sec, &ret );
+        return ret;
+} // getTime
+
 // Local Variables: //
 // mode: c //