implement basic operations over class Time

[libi2ncommon] / src / timefunc.cpp

diff --git a/src/timefunc.cpp b/src/timefunc.cpp
index ab5f6dc..30df7a6 100644 (file)
--- a/src/timefunc.cpp
+++ b/src/timefunc.cpp
@@ -37,7 +37,6 @@ on this file might be covered by the GNU General Public License.
 #include <unistd.h>
 #include <string.h>
 #include <sys/timeb.h>
-#include <sys/syscall.h>
 
 #include <timefunc.hxx>
 #include <i18n.h>
@@ -69,9 +68,10 @@ double prec_time(void)
 }
 
 // converts ISO-DATE: 2003-06-13
-int date_to_seconds(const std::string &date)
+time_t date_to_seconds(const std::string &date)
 {
-    int rtn = -1, year = -1, month = -1, day = -1;
+    time_t rtn = 0;
+    int year = -1, month = -1, day = -1;
     
     string::size_type pos = date.find("-");
     if (pos == string::npos)
@@ -118,10 +118,8 @@ string make_nice_time(int seconds)
     int hours,minutes;
     split_daysec(seconds,&hours,&minutes,&seconds);
     
-    if (days==1)
-        out << i18n("1 day") << ", ";
-    else if (days>1)
-        out << days << ' ' << i18n("days") << ", ";
+    if (days>0)
+        out << days << " " << i18n_plural("day", "days", days) << ", ";
 
     out << setfill('0');
     out << setw(2) << hours << ':' << setw(2) << minutes << ':' << setw(2) << seconds;
@@ -129,7 +127,7 @@ string make_nice_time(int seconds)
     return out.str();
 }
 
-string format_full_time(int seconds)
+string format_full_time(time_t seconds)
 {
     char buf[50];
     memset (buf, 0, 50);
@@ -141,6 +139,18 @@ string format_full_time(int seconds)
     return string(buf);
 }
 
+string format_date(time_t seconds)
+{
+    char buf[50];
+    memset (buf, 0, 50);
+    struct tm ta;
+    if (localtime_r((time_t *)&seconds, &ta) == NULL)
+        memset (&ta, 0, sizeof(struct tm));
+
+    strftime (buf, 49, "%d.%m.%Y", &ta);
+    return string(buf);
+}
+
 void seconds_to_hour_minute(int seconds, int *hour, int *minute)
 {
     if (hour != NULL) {
@@ -712,7 +722,7 @@ Intervals& Intervals::operator-=(const Intervals& other)
 bool monotonic_clock_gettime(long int& seconds, long int& nano_seconds)
 {
     struct timespec tp[1];
-    int res= ::syscall(__NR_clock_gettime, CLOCK_MONOTONIC, tp);
+    int res= clock_gettime (CLOCK_MONOTONIC, tp);
     if (0 == res)
     {
         seconds= tp->tv_sec;
@@ -751,7 +761,7 @@ long long monotonic_clock_gettime_nano()
 bool realtime_clock_gettime(long int& seconds, long int& nano_seconds)
 {
     struct timespec tp[1];
-    int res= ::syscall(__NR_clock_gettime, CLOCK_REALTIME, tp);
+    int res= clock_gettime(CLOCK_REALTIME, tp);
     if (0 == res)
     {
         seconds= tp->tv_sec;
@@ -761,3 +771,205 @@ bool realtime_clock_gettime(long int& seconds, long int& nano_seconds)
 } // eo realtime_clock_gettime(long int&,long int&)
 
 
+namespace I2n {
+
+namespace clock {
+
+    namespace {
+
+        static inline clockid_t
+        clockid_of_flags (const enum type::id      id,
+                          const enum type::variant var) NOEXCEPT
+        {
+            clockid_t cid = CLOCK_MONOTONIC_COARSE;
+
+            switch (id) {
+
+                default:
+                case type::mono: {
+                    switch (var) {
+                        default: {
+                            break;
+                        }
+                        case type::raw: {
+                            cid = CLOCK_MONOTONIC_RAW;
+                            break;
+                        }
+                        case type::exact: {
+                            cid = CLOCK_MONOTONIC;
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case type::real: {
+                    if (var == type::exact) {
+                        cid = CLOCK_REALTIME;
+                    } else {
+                        cid = CLOCK_REALTIME_COARSE;
+                    }
+                    break;
+                }
+
+                case type::boot: {
+                    if (var & type::exact) {
+                        cid = CLOCK_BOOTTIME;
+                    }
+                    break;
+                }
+
+                case type::cpu: {
+                    if (var == type::thread) {
+                        cid = CLOCK_THREAD_CPUTIME_ID;
+                    } else {
+                        cid = CLOCK_PROCESS_CPUTIME_ID;
+                    }
+                    break;
+                }
+            } /* [switch id] */
+
+            return cid;
+        }
+
+        static const struct timespec zero_time = { 0, 0 };
+
+    } /* [namespace] */
+
+    Time::Time (const enum type::id id,
+                const enum type::variant var) NOEXCEPT
+        : value   (zero_time)
+        , id      (id)
+        , variant (var)
+        , err     (0)
+    { }
+
+    int64_t
+    Time::as_nanosec (void) const NOEXCEPT
+    {
+        return int64_t (this->value.tv_sec) * TIME_CONST_FACTOR_NANO
+             + this->value.tv_nsec;
+    }
+
+    long
+    Time::as_nanosec_L (void) const NOEXCEPT /* likely to overflow */
+    { return static_cast<long>(this->as_nanosec ()); }
+
+    Time &
+    Time::operator= (Time t2) NOEXCEPT
+    {
+        this->swap (t2);
+
+        return *this;
+    }
+
+    Time &
+    Time::operator= (struct timespec ts) NOEXCEPT
+    {
+        std::swap (this->value, ts);
+        this->id      = clock::type::mono;
+        this->variant = clock::type::dflt;
+        this->err     = 0;
+
+        return *this;
+    }
+
+    void
+    Time::unset (void) NOEXCEPT
+    { this->value = zero_time; }
+
+    bool
+    Time::set (void) NOEXCEPT
+    {
+        struct timespec now;
+
+        errno = 0;
+        if (clock_gettime (clockid_of_flags (this->id, this->variant), &now)
+            == -1)
+        {
+            this->err = errno;
+            this->unset ();
+
+            return false;
+        }
+        this->err   = 0;
+        this->value = now;
+
+        return true;
+    }
+
+    Time &
+    Time::add (const time_t sec, const long nsec) NOEXCEPT
+    {
+        this->value.tv_sec  += sec;
+        this->value.tv_nsec += nsec;
+
+        this->carry_nsec ();
+
+        return *this;
+    }
+
+    Time &
+    Time::subtract (const time_t sec, const long nsec) NOEXCEPT
+    {
+        this->value.tv_sec  -= sec;
+        this->value.tv_nsec -= nsec;
+
+        this->carry_nsec ();
+
+        return *this;
+    }
+
+    Time &
+    Time::scale (const time_t factor) NOEXCEPT
+    {
+        this->value.tv_sec  *= factor;
+        this->value.tv_nsec *= factor;
+
+        this->carry_nsec ();
+
+        return *this;
+    }
+
+    boost::optional<Time>
+    now (const enum type::id id, const enum type::variant var) NOEXCEPT
+    {
+        Time ret (id, var);
+
+        if (!ret.set ()) {
+            return boost::none;
+        }
+
+        return ret;
+    }
+
+    Time
+    zero (const enum type::id id, const enum type::variant var) NOEXCEPT
+    { return Time (id, var); }
+
+    int
+    compare (const Time &t1, const Time &t2) NOEXCEPT
+    {
+        if (t1.value.tv_sec < t2.value.tv_sec) {
+            return -1;
+        }
+
+        if (t1.value.tv_sec > t2.value.tv_sec) {
+            return 1;
+        }
+
+        if (t1.value.tv_nsec < t2.value.tv_nsec) {
+            return -1;
+        }
+
+        if (t1.value.tv_nsec > t2.value.tv_nsec) {
+            return 1;
+        }
+
+        return 0;
+    }
+
+} /* [namespace clock] */
+
+} /* [namespace I2n] */
+