Index: src/libcfa/time
===================================================================
--- src/libcfa/time	(revision bc03be389ffa6ebe951b6f27c39cce6f746fd594)
+++ src/libcfa/time	(revision 643c6b943be1c4a0bc15604b1d1af2e9eb93875d)
@@ -10,6 +10,6 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr  4 16:28:48 2018
-// Update Count     : 595
+// Last Modified On : Fri Apr  6 11:15:49 2018
+// Update Count     : 610
 // 
 
@@ -28,5 +28,79 @@
 
 
-//######################### timeval #########################
+//######################### 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 }; }
+
+static inline Duration +?( Duration rhs ) with( rhs ) {	return (Duration)@{ +tv }; }
+static inline Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
+static inline Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
+
+static inline Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
+static inline Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+static inline Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
+
+static inline Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
+static inline Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
+static inline Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
+
+static inline int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
+static inline Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
+static inline Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
+static inline double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
+
+static inline Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
+static inline Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
+
+static inline _Bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
+static inline _Bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
+static inline _Bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
+static inline _Bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
+static inline _Bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
+static inline _Bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
+
+static inline _Bool ?==?( Duration lhs, zero_t ) { return lhs.tv == 0; }
+static inline _Bool ?!=?( Duration lhs, zero_t ) { return lhs.tv != 0; }
+static inline _Bool ?<? ( Duration lhs, zero_t ) { return lhs.tv <  0; }
+static inline _Bool ?<=?( Duration lhs, zero_t ) { return lhs.tv <= 0; }
+static inline _Bool ?>? ( Duration lhs, zero_t ) { return lhs.tv >  0; }
+static inline _Bool ?>=?( Duration lhs, zero_t ) { return lhs.tv >= 0; }
+
+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 }; }
+static inline Duration ?`us( int64_t usec ) { return (Duration)@{ usec * (TIMEGRAN / 1_000_000LL) }; }
+static inline Duration ?`ms( int64_t msec ) { return (Duration)@{ msec * (TIMEGRAN / 1_000LL) }; }
+static inline Duration ?`s( int64_t sec ) { return (Duration)@{ sec * TIMEGRAN }; }
+static inline Duration ?`s( double sec ) { return (Duration)@{ sec * TIMEGRAN }; }
+static inline Duration ?`m( int64_t min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
+static inline Duration ?`m( double min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
+static inline Duration ?`h( int64_t hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
+static inline Duration ?`h( double hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
+static inline Duration ?`d( int64_t days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
+static inline Duration ?`d( double days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
+static inline Duration ?`w( int64_t weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
+static inline Duration ?`w( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
+
+static inline int64_t ?`ns( Duration dur ) { return dur.tv; }
+static inline int64_t ?`us( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
+static inline int64_t ?`ms( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
+static inline int64_t ?`s( Duration dur ) { return dur.tv / TIMEGRAN; }
+static inline int64_t ?`m( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
+static inline int64_t ?`h( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
+static inline int64_t ?`d( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
+static inline int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
+
+
+//######################### C timeval #########################
 
 static inline void ?{}( timeval & t ) {}
@@ -41,5 +115,5 @@
 
 
-//######################### timespec #########################
+//######################### C timespec #########################
 
 static inline void ?{}( timespec & t ) {}
@@ -64,150 +138,12 @@
 
 
-//######################### Duration #########################
-
-struct Duration {
-	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 }; }
-
-#if 0
-static inline void ?{}( Duration & dur, timeval t ) with( dur ) {
-	tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000;
-} // Duration
-
-static inline void ?{}( Duration & dur, timespec t ) with( dur ) {
-	tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
-} // Duration
-
-static inline Duration ?=?( Duration & dur, timeval t ) with( dur ) {
-	tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000;
-	return dur;
-} // ?=?
-
-static inline Duration ?=?( Duration & dur, timespec t ) with( dur ) {
-	tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
-	return dur;
-} // ?=? timespec
-
-//------------------------- timeval (cont) -------------------------
-
-static inline void ?{}( timeval & t, Duration dur ) with( dur ) {
-	t.tv_sec = tv / TIMEGRAN;							// seconds
-	t.tv_usec = tv % TIMEGRAN / (TIMEGRAN / 1_000_000LL); // microseconds
-} // ?{}
-
-//------------------------- timespec (cont) -------------------------
-
-static inline void ?{}( timespec & t, Duration dur ) with( dur ) {
-	t.tv_sec = tv / TIMEGRAN;							// seconds
-	t.tv_nsec = tv % TIMEGRAN;							// nanoseconds
-} // Timespec
-
-static inline int64_t nsecs( Duration dur ) with( dur ) { return tv; }
-#endif
-
-static inline Duration +?( Duration rhs ) with( rhs ) {	return (Duration)@{ +tv }; }
-static inline Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
-static inline Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
-
-static inline Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
-static inline Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
-static inline Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
-
-static inline Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
-static inline Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
-static inline Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
-
-static inline int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
-static inline Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
-static inline Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
-
-static inline Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
-static inline Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
-
-static inline _Bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
-static inline _Bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
-static inline _Bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
-static inline _Bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
-static inline _Bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
-static inline _Bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
-
-static inline _Bool ?==?( Duration lhs, zero_t ) { return lhs.tv == 0; }
-static inline _Bool ?!=?( Duration lhs, zero_t ) { return lhs.tv != 0; }
-static inline _Bool ?<? ( Duration lhs, zero_t ) { return lhs.tv <  0; }
-static inline _Bool ?<=?( Duration lhs, zero_t ) { return lhs.tv <= 0; }
-static inline _Bool ?>? ( Duration lhs, zero_t ) { return lhs.tv >  0; }
-static inline _Bool ?>=?( Duration lhs, zero_t ) { return lhs.tv >= 0; }
-
-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 }; }
-static inline Duration ?`us( int64_t usec ) { return (Duration)@{ usec * (TIMEGRAN / 1_000_000LL) }; }
-static inline Duration ?`ms( int64_t msec ) { return (Duration)@{ msec * (TIMEGRAN / 1_000LL) }; }
-static inline Duration ?`s ( int64_t sec ) { return (Duration)@{ sec * TIMEGRAN }; }
-static inline Duration ?`s ( double sec ) { return (Duration)@{ sec * TIMEGRAN }; }
-static inline Duration ?`m ( int64_t min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
-static inline Duration ?`m ( double min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
-static inline Duration ?`h ( int64_t hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`h ( double hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`d ( int64_t days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`d ( double days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`w ( int64_t weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`w ( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
-//static inline Duration ?`f ( int64_t fortnight ) { return (Duration)@{ fortnight * (14LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
-//static inline Duration ?`f ( double  fortnight ) { return (Duration)@{ fortnight * (14LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
-
-static inline int64_t ?`ns ( Duration dur ) { return dur.tv; }
-static inline int64_t ?`us ( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
-static inline int64_t ?`ms ( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
-static inline int64_t ?`s  ( Duration dur ) { return dur.tv / TIMEGRAN; }
-static inline int64_t ?`m  ( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
-static inline int64_t ?`h  ( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
-static inline int64_t ?`d  ( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
-static inline int64_t ?`w  ( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
-static inline int64_t ?`f  ( Duration dur ) { return dur.tv / (14LL * 24LL * 60LL * 60LL * TIMEGRAN); }
-
-
 //######################### Time #########################
 
-struct Time {
+struct Time {											// private
 	uint64_t tv;										// nanoseconds since UNIX epoch
 };
 
-static inline void ?{}( Time & t ) with( t ) {
-	tv = 0;
-} // Time
-
-void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int nsec );
-
-static inline void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec ) {
-	time{ year, month, day, hour, min, sec, 0 };
-} // Time
-
-static inline void ?{}( Time & time, int year, int month, int day, int hour, int min ) {
-	time{ year, month, day, hour, min, 0, 0 };
-} // Time
-
-static inline void ?{}( Time & time, int year, int month, int day, int hour ) {
-	time{ year, month, day, hour, 0, 0, 0 };
-} // Time
-
-static inline void ?{}( Time & time, int year, int month, int day ) {
-	time{ year, month, day, 0, 0, 0, 0 };
-} // Time
-
-static inline void ?{}( Time & time, int year, int month ) {
-	time{ year, month, 0, 0, 0, 0, 0 };
-} // Time
-
-static inline void ?{}( Time & time, int year ) {
-	time{ year, 0, 0, 0, 0, 0, 0 };
-} // 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; }
@@ -247,15 +183,15 @@
 
 char * yy_mm_dd( Time time, char * buf );
-static inline char * ?`ymd( Time time, char * buf ) {
+static inline char * ?`ymd( Time time, char * buf ) {	// short form
 	return yy_mm_dd( time, buf );
 } // ymd
 
 char * mm_dd_yy( Time time, char * buf );
-static inline char * ?`mdy( Time time, char * buf ) {
+static inline char * ?`mdy( Time time, char * buf ) {	// short form
 	return mm_dd_yy( time, buf );
 } // mdy
 
 char * dd_mm_yy( Time time, char * buf );
-static inline char * ?`dmy( Time time, char * buf ) {
+static inline char * ?`dmy( Time time, char * buf ) {	// short form
 	return dd_mm_yy( time, buf );;
 } // dmy
@@ -282,5 +218,5 @@
 //######################### Clock #########################
 
-struct Clock {
+struct Clock {											// private
 	Duration offset;									// for virtual clock: contains offset from real-time
 	int clocktype;										// implementation only -1 (virtual), CLOCK_REALTIME
@@ -293,5 +229,5 @@
 static inline void resetClock( Clock & clk, Duration adj ) with( clk ) {
 	clocktype = -1;
-	offset = adj + timezone`s;							// timezone is (UTC - local time) in seconds
+	offset = adj + timezone`s;							// timezone (global) is (UTC - local time) in seconds
 } // resetClock