diff --git a/echrono/Clock.cpp b/echrono/Clock.cpp index c1e679d..2b1c8cc 100644 --- a/echrono/Clock.cpp +++ b/echrono/Clock.cpp @@ -11,20 +11,19 @@ #include #include -echrono::Clock::Clock() { - m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0)); +echrono::Clock::Clock() : + m_data(0) { + } -echrono::Clock::Clock(int64_t _valNano) { - m_data = std::chrono::steady_clock::time_point(std::chrono::nanoseconds(_valNano)); +echrono::Clock::Clock(int64_t _valNano) : + m_data(_valNano) { + } -echrono::Clock::Clock(int64_t _valSec, int64_t _valNano) { - m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(_valSec)); - m_data += std::chrono::nanoseconds(_valNano); -} -echrono::Clock::Clock(const std::chrono::steady_clock::time_point& _val) { - m_data = _val; +echrono::Clock::Clock(int64_t _valSec, int64_t _valNano) : + m_data(_valSec*1000000000LL +_valNano) { + } echrono::Clock::Clock(const echrono::Steady& _val) { @@ -32,7 +31,7 @@ echrono::Clock::Clock(const echrono::Steady& _val) { } echrono::Clock echrono::Clock::now() { - return echrono::Clock(std::chrono::steady_clock::now()); + return echrono::Clock(echrono::Steady::now()); } const echrono::Clock& echrono::Clock::operator= (const echrono::Clock& _obj) { @@ -65,60 +64,41 @@ bool echrono::Clock::operator>= (const echrono::Clock& _obj) const { } const echrono::Clock& echrono::Clock::operator+= (const echrono::Duration& _obj) { - #if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs) - std::chrono::microseconds ms = std::chrono::duration_cast(_obj.get()); - m_data += ms; - #else - m_data += _obj.get(); - #endif + m_data += _obj.get(); return *this; } echrono::Clock echrono::Clock::operator+ (const echrono::Duration& _obj) const { - echrono::Clock time(m_data); - time += _obj; - return time; + echrono::Clock tmp(m_data); + tmp += _obj; + return tmp; } const echrono::Clock& echrono::Clock::operator-= (const echrono::Duration& _obj) { - #if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs) - std::chrono::microseconds ms = std::chrono::duration_cast(_obj.get()); - m_data -= ms; - #else - m_data -= _obj.get(); - #endif + m_data -= _obj.get(); return *this; } echrono::Clock echrono::Clock::operator- (const echrono::Duration& _obj) const { - echrono::Clock time(m_data); - time -= _obj; - return time; + echrono::Clock tmp(m_data); + tmp -= _obj; + return tmp; } echrono::Duration echrono::Clock::operator- (const echrono::Clock& _obj) const { - std::chrono::nanoseconds ns = std::chrono::duration_cast(m_data.time_since_epoch()); - std::chrono::nanoseconds ns2 = std::chrono::duration_cast(_obj.m_data.time_since_epoch()); - echrono::Duration duration(ns); - echrono::Duration duration2(ns2); - return duration - duration2; + return _obj.m_data - m_data; } void echrono::Clock::reset() { - m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0)); -} - -int64_t echrono::Clock::count() { - std::chrono::nanoseconds ns = std::chrono::duration_cast(m_data.time_since_epoch()); - return ns.count()/1000; + m_data = 0; } etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Clock& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - int64_t totalSecond = ns.count()/1000000000; - int64_t millisecond = (ns.count()%1000000000)/1000000; - int64_t microsecond = (ns.count()%1000000)/1000; - int64_t nanosecond = ns.count()%1000; + int64_t ns = _obj.get() + int64_t totalSecond = ns/1000000000; + int64_t millisecond = (ns%1000000000)/1000000; + int64_t microsecond = (ns%1000000)/1000; + int64_t nanosecond = ns%1000; //_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns"; int32_t second = totalSecond % 60; int32_t minute = (totalSecond/60)%60; @@ -161,13 +141,10 @@ etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Clock& _obj) namespace etk { template<> etk::String toString(const echrono::Clock& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - return etk::toString(ns.count()); + ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); + return etk::toString(_obj.get()); + } + template<> etk::UString toUString(const echrono::Clock& _obj) { + return etk::toUString(_obj.get()); } - #if __CPP_VERSION__ >= 2011 - template<> etk::UString toUString(const echrono::Clock& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - return etk::toUString(ns.count()); - } - #endif } diff --git a/echrono/Clock.hpp b/echrono/Clock.hpp index 0d72f8e..0e866bb 100644 --- a/echrono/Clock.hpp +++ b/echrono/Clock.hpp @@ -7,7 +7,6 @@ #include #include -#include namespace echrono { class Duration; @@ -17,23 +16,22 @@ namespace echrono { */ class Clock { private: - std::chrono::steady_clock::time_point m_data; + int64_t m_data; public: Clock(); //Clock(const echrono::Duration& _val) {}; //value in second Clock(int64_t _valNano); - Clock(int64_t _valSec, int64_t _valNano); - Clock(const std::chrono::steady_clock::time_point& _val); + Clock(int64_t _valSec, uint32_t _valNano); + Clock(const echrono::Clock& _val); Clock(const echrono::Steady& _val); ~Clock() {}; - const std::chrono::steady_clock::time_point& get() const { + const int64_t& get() const { return m_data; } /** * @brief return the number of us since start of clock (can be <0) * @return a number un us since start of clock */ - int64_t count(); static Clock now(); const Clock& operator= (const echrono::Clock& _obj ); bool operator== (const echrono::Clock& _obj) const; diff --git a/echrono/Duration.cpp b/echrono/Duration.cpp index c7f32c2..bd51c79 100644 --- a/echrono/Duration.cpp +++ b/echrono/Duration.cpp @@ -10,46 +10,28 @@ #include #include -echrono::Duration::Duration() { - m_data = std::chrono::nanoseconds(0); +echrono::Duration::Duration() : + m_data(0) { + } -echrono::Duration::Duration(int _val) { - m_data = std::chrono::nanoseconds(_val); +echrono::Duration::Duration(int _val) : + m_data(_val) { { + } -echrono::Duration::Duration(int64_t _valSec, int64_t _valNano) { - m_data = std::chrono::duration_cast(std::chrono::seconds(_valSec)); - m_data += std::chrono::nanoseconds(_valNano); +echrono::Duration::Duration(int64_t _valSec, int64_t _valNano) : + m_data(_valSec*1000000000LL +_valNano) { + } -echrono::Duration::Duration(int64_t _val) { +echrono::Duration::Duration(int64_t _val) : + m_data(0) { { m_data = std::chrono::nanoseconds(_val); } echrono::Duration::Duration(double _val) { - m_data = std::chrono::duration_cast(std::chrono::seconds(int64_t(_val))); - m_data += std::chrono::nanoseconds(int64_t(((_val - int64_t(_val)) * 1000000000.0))); -} - -echrono::Duration::Duration(echrono::nanoseconds _val) { - m_data = std::chrono::duration_cast(_val); -} - -echrono::Duration::Duration(echrono::microseconds _val) { - m_data = std::chrono::duration_cast(_val); -} - -echrono::Duration::Duration(echrono::milliseconds _val) { - m_data = std::chrono::duration_cast(_val); -} - -echrono::Duration::Duration(echrono::seconds _val) { - m_data = std::chrono::duration_cast(_val); -} - -int64_t echrono::Duration::count() const { - return m_data.count(); + m_data = int64_t(_val*1000000000.0); } const echrono::Duration& echrono::Duration::operator= (const echrono::Duration& _obj) { @@ -76,26 +58,24 @@ bool echrono::Duration::operator>= (const echrono::Duration& _obj) const { } double echrono::Duration::toSeconds() const { - return double(m_data.count()) * 0.000000001; + return double(m_data) * 0.000000001; } const echrono::Duration& echrono::Duration::operator/= (float _value) { - m_data = std::chrono::nanoseconds(int64_t(double(m_data.count()) / _value)); + m_data = int64_t(double(m_data) / _value); return *this; } echrono::Duration echrono::Duration::operator/ (float _value) const { - echrono::Duration tmpp(int64_t(double(m_data.count()) / _value)); - return tmpp; + return echrono::Duration(int64_t(double(m_data) / _value)); } const echrono::Duration& echrono::Duration::operator*= (float _value) { - m_data = std::chrono::nanoseconds(int64_t(double(m_data.count()) * _value)); + m_data = int64_t(double(m_data) * _value); return *this; } echrono::Duration echrono::Duration::operator* (float _value) const { - echrono::Duration tmpp(int64_t(double(m_data.count()) * _value)); - return tmpp; + return echrono::Duration(int64_t(double(m_data.count()) * _value)); } const echrono::Duration& echrono::Duration::operator+= (const echrono::Duration& _obj) { @@ -103,9 +83,9 @@ const echrono::Duration& echrono::Duration::operator+= (const echrono::Duration& return *this; } echrono::Duration echrono::Duration::operator+ (const echrono::Duration& _obj) const { - echrono::Duration tmpp(m_data); - tmpp.m_data += _obj.m_data; - return tmpp; + echrono::Duration tmp(m_data); + tmp.m_data += _obj.m_data; + return tmp; } const echrono::Duration& echrono::Duration::operator-= (const echrono::Duration& _obj) { @@ -113,39 +93,39 @@ const echrono::Duration& echrono::Duration::operator-= (const echrono::Duration& return *this; } echrono::Duration echrono::Duration::operator- (const echrono::Duration& _obj) const { - echrono::Duration tmpp(m_data); - tmpp.m_data -= _obj.m_data; - return tmpp; + echrono::Duration tmp(m_data); + tmp.m_data -= _obj.m_data; + return tmp; } echrono::Duration& echrono::Duration::operator++() { - m_data += std::chrono::nanoseconds(1); + m_data++; return *this; } echrono::Duration echrono::Duration::operator++(int _unused) { - echrono::Duration result(m_data); - m_data += std::chrono::nanoseconds(1); - return result; + echrono::Duration tmp(m_data); + m_data++; + return tmp; } echrono::Duration& echrono::Duration::operator--() { - m_data -= std::chrono::nanoseconds(1); + m_data -= echrono::nanoseconds(1); return *this; } echrono::Duration echrono::Duration::operator--(int _unused) { - m_data -= std::chrono::nanoseconds(1); - echrono::Duration result(m_data); - return result; + echrono::Duration tmp(m_data); + m_data--; + return tmp; } void echrono::Duration::reset() { - m_data = std::chrono::nanoseconds(0); + m_data = 0; } etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Duration& _obj) { - int64_t totalSecond = _obj.count()/1000000000; - int64_t millisecond = (_obj.count()%1000000000)/1000000; - int64_t microsecond = (_obj.count()%1000000)/1000; - int64_t nanosecond = _obj.count()%1000; + int64_t totalSecond = _obj.get()/1000000000; + int64_t millisecond = (_obj.get()%1000000000)/1000000; + int64_t microsecond = (_obj.get()%1000000)/1000; + int64_t nanosecond = _obj.get()%1000; //_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns"; int32_t second = totalSecond % 60; int32_t minute = (totalSecond/60)%60; @@ -187,13 +167,11 @@ etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Duration& _ob namespace etk { template<> etk::String toString(const echrono::Duration& _obj) { - return etk::toString(_obj.count()); + return etk::toString(_obj.get()); + } + template<> etk::UString toUString(const echrono::Duration& _obj) { + return etk::toUString(_obj.get()); } - #if __CPP_VERSION__ >= 2011 - template<> etk::UString toUString(const echrono::Duration& _obj) { - return etk::toUString(_obj.count()); - } - #endif } diff --git a/echrono/Duration.hpp b/echrono/Duration.hpp index e65cd3f..3ba92d5 100644 --- a/echrono/Duration.hpp +++ b/echrono/Duration.hpp @@ -9,27 +9,43 @@ #include namespace echrono { - using nanoseconds = std::chrono::nanoseconds; - using microseconds = std::chrono::microseconds; - using milliseconds = std::chrono::milliseconds; - using seconds = std::chrono::seconds; + template + class genericOffsetTime { + private: + int64_t m_duration; + public: + genericOffsetTime(int32_t _offsetSinceEpock=0) : + m_duration(_nanoSecondSinceEpock*int64_t(ECHRONO_FACTOR)) { + // nothing to do. + } + int64_t get() { + return m_duration; + } + }; + using nanoseconds = genericOffsetTime<1LL> + using microseconds = genericOffsetTime<1000LL>; + using milliseconds = genericOffsetTime<1000000LL>; + using seconds = genericOffsetTime<1000000000LL>; + using minutes = genericOffsetTime<60000000000LL>; + using hours = genericOffsetTime<3600000000000LL>; + using days = genericOffsetTime<86400000000000LL>; class Duration { private: - echrono::nanoseconds m_data; + int64_t m_data; public: Duration(); Duration(int _val); //value in nanosecond Duration(int64_t _val); //value in nanosecond Duration(int64_t _valSec, int64_t _valNano); //value in second and nanosecond Duration(double _val); //value in second - Duration(echrono::nanoseconds _val); - Duration(echrono::microseconds _val); - Duration(echrono::milliseconds _val); - Duration(echrono::seconds _val); + template + Duration(const genericOffsetTime& _val) { + m_data = _val.get(); + } ~Duration() { }; int64_t count() const; - const echrono::nanoseconds& get() const { + const int64_t& get() const { return m_data; } const Duration& operator= (const Duration& _obj); diff --git a/echrono/Steady.cpp b/echrono/Steady.cpp index 824b56d..3f677c0 100644 --- a/echrono/Steady.cpp +++ b/echrono/Steady.cpp @@ -9,18 +9,53 @@ #include #include #include +#include -echrono::Steady::Steady() { - m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0)); +static int64_t getTime() { + #if defined(__TARGET_OS__Android) + struct timevalnow; + gettimeofday(&now, nullptr); + return int64_t(now.tv_sec)*1000000LL + int64_t(now.tv_usec); + #elif defined(__TARGET_OS__Web) \ + || defined(__TARGET_OS__Linux) \ + || defined(__TARGET_OS__buildroot) + struct timespec now; + int ret = clock_gettime(CLOCK_UPTIME_RAW, &now); + if (ret != 0) { + // Error to get the time ... + now.tv_sec = time(nullptr); + now.tv_nsec = 0; + } + m_data = int64_t(now.tv_sec)*1000000LL + int64_t(now.tv_nsec)/1000LL; + #elif defined(__TARGET_OS__MacOs) \ + || defined(__TARGET_OS__IOs) + struct timespec now; + clock_serv_t cclock; + mach_timespec_t mts; + host_get_clock_service(mach_host_self(), REALTIME_CLOCK, &cclock); + clock_get_time(cclock, &mts); + mach_port_deallocate(mach_task_self(), cclock); + now.tv_sec = mts.tv_sec; + now.tv_nsec = mts.tv_nsec; + return int64_t(now.tv_sec)*1000000LL + int64_t(now.tv_nsec)/1000LL; + #else + #error must be implemented ... + #endif + return 0; +} + +echrono::Steady::Steady() : + m_data(0) { + } echrono::Steady::Steady(int64_t _valNano) { m_data = std::chrono::steady_clock::time_point(std::chrono::nanoseconds(_valNano)); } -echrono::Steady::Steady(int64_t _valSec, int64_t _valNano) { - m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(_valSec)); - m_data += std::chrono::nanoseconds(_valNano); +echrono::Steady::Steady(int64_t _valSec, int64_t _valNano) : + m_data(_valSec*1000000000LL +_valNano) { + } echrono::Steady::Steady(const std::chrono::steady_clock::time_point& _val) { @@ -61,60 +96,41 @@ bool echrono::Steady::operator>= (const echrono::Steady& _obj) const { } const echrono::Steady& echrono::Steady::operator+= (const echrono::Duration& _obj) { - #if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs) - std::chrono::microseconds ms = std::chrono::duration_cast(_obj.get()); - m_data += ms; - #else - m_data += _obj.get(); - #endif + m_data += _obj.get(); return *this; } echrono::Steady echrono::Steady::operator+ (const echrono::Duration& _obj) const { - echrono::Steady time(m_data); - time += _obj; - return time; + echrono::Steady tmp(m_data); + tmp += _obj; + return tmp; } const echrono::Steady& echrono::Steady::operator-= (const echrono::Duration& _obj) { - #if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs) - std::chrono::microseconds ms = std::chrono::duration_cast(_obj.get()); - m_data -= ms; - #else - m_data -= _obj.get(); - #endif + m_data -= _obj.get(); return *this; } echrono::Steady echrono::Steady::operator- (const echrono::Duration& _obj) const { - echrono::Steady time(m_data); - time -= _obj; - return time; + echrono::Steady tmp(m_data); + tmp -= _obj; + return tmp; } echrono::Duration echrono::Steady::operator- (const echrono::Steady& _obj) const { - std::chrono::nanoseconds ns = std::chrono::duration_cast(m_data.time_since_epoch()); - std::chrono::nanoseconds ns2 = std::chrono::duration_cast(_obj.m_data.time_since_epoch()); - echrono::Duration duration(ns); - echrono::Duration duration2(ns2); - return duration - duration2; + return m_data - _obj.m_data; } void echrono::Steady::reset() { - m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0)); -} - -int64_t echrono::Steady::count() { - std::chrono::nanoseconds ns = std::chrono::duration_cast(m_data.time_since_epoch()); - return ns.count()/1000; + m_data = 0; } etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Steady& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - int64_t totalSecond = ns.count()/1000000000; - int64_t millisecond = (ns.count()%1000000000)/1000000; - int64_t microsecond = (ns.count()%1000000)/1000; - int64_t nanosecond = ns.count()%1000; + int64_t ns = obj.get(); + int64_t totalSecond = ns/1000000000; + int64_t millisecond = (ns%1000000000)/1000000; + int64_t microsecond = (ns%1000000)/1000; + int64_t nanosecond = ns%1000; //_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns"; int32_t second = totalSecond % 60; int32_t minute = (totalSecond/60)%60; @@ -156,13 +172,9 @@ etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Steady& _obj) namespace etk { template<> etk::String toString(const echrono::Steady& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - return etk::toString(ns.count()); + return etk::toString(_obj.get()); + } + template<> etk::UString toUString(const echrono::Steady& _obj) { + return etk::toUString(_obj.get()); } - #if __CPP_VERSION__ >= 2011 - template<> etk::UString toUString(const echrono::Steady& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - return etk::toUString(ns.count()); - } - #endif } diff --git a/echrono/Steady.hpp b/echrono/Steady.hpp index e7f097e..63184a4 100644 --- a/echrono/Steady.hpp +++ b/echrono/Steady.hpp @@ -7,7 +7,6 @@ #include #include -#include namespace echrono { class Duration; @@ -16,15 +15,15 @@ namespace echrono { */ class Steady { private: - std::chrono::steady_clock::time_point m_data; + uint64_t m_data; //!< Monotonic clock since computer star public: Steady(); //Steady(const echrono::Duration& _val) {}; //value in second Steady(int64_t _valNano); Steady(int64_t _valSec, int64_t _valNano); - Steady(const std::chrono::steady_clock::time_point& _val); + Steady(const echrono::Steady& _obj); ~Steady() {}; - const std::chrono::steady_clock::time_point& get() const { + const int64_t& get() const { return m_data; } /** diff --git a/echrono/Time.cpp b/echrono/Time.cpp index d6aed8a..bdbe42b 100644 --- a/echrono/Time.cpp +++ b/echrono/Time.cpp @@ -11,37 +11,60 @@ #include #include -echrono::Time::Time() { - m_data = std::chrono::system_clock::time_point(std::chrono::seconds(0)); -} - -echrono::Time::Time(int64_t _valNano) { - #if defined(__TARGET_OS__MacOs) \ - or defined(__TARGET_OS__IOs) \ - or defined(__TARGET_OS__Web) - m_data = std::chrono::system_clock::time_point(std::chrono::milliseconds(_valNano/1000)); +static int64_t getTime() { + #if defined(__TARGET_OS__Android) + struct timevalnow; + gettimeofday(&now, nullptr); + return int64_t(now.tv_sec)*1000000LL + int64_t(now.tv_usec); + #elif defined(__TARGET_OS__Web) \ + || defined(__TARGET_OS__Linux) \ + || defined(__TARGET_OS__buildroot) + struct timespec now; + int ret = clock_gettime(CLOCK_REALTIME, &now); + if (ret != 0) { + // Error to get the time ... + now.tv_sec = time(nullptr); + now.tv_nsec = 0; + } + m_data = int64_t(now.tv_sec)*1000000LL + int64_t(now.tv_nsec)/1000LL; + #elif defined(__TARGET_OS__MacOs) \ + || defined(__TARGET_OS__IOs) + struct timespec now; + clock_serv_t cclock; + mach_timespec_t mts; + host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); + clock_get_time(cclock, &mts); + mach_port_deallocate(mach_task_self(), cclock); + now.tv_sec = mts.tv_sec; + now.tv_nsec = mts.tv_nsec; + return int64_t(now.tv_sec)*1000000LL + int64_t(now.tv_nsec)/1000LL; #else - m_data = std::chrono::system_clock::time_point(std::chrono::nanoseconds(_valNano)); + #error must be implemented ... #endif + return 0; } -echrono::Time::Time(int64_t _valSec, int64_t _valNano) { - m_data = std::chrono::system_clock::time_point(std::chrono::seconds(_valSec)); - #if defined(__TARGET_OS__MacOs) \ - or defined(__TARGET_OS__IOs) \ - or defined(__TARGET_OS__Web) - m_data += std::chrono::milliseconds(_valNano/1000); - #else - m_data += std::chrono::nanoseconds(_valNano); - #endif +echrono::Time::Time() : + m_data(0) { + } -echrono::Time::Time(const std::chrono::system_clock::time_point& _val) { - m_data = _val; +echrono::Time::Time(int64_t _valNano) : + m_data(_valNano) { + +} + +echrono::Time::Time(int64_t _valSec, int64_t _valNano) : + m_data(_valSec*1000000000LL +_valNano) { + +} + +echrono::Time::Time(const echrono::Time& _val) { + m_data = _val.m_data; } echrono::Time echrono::Time::now() { - return echrono::Time(std::chrono::system_clock::now()); + return echrono::Time(getTime()); } const echrono::Time& echrono::Time::operator= (const echrono::Time& _obj) { @@ -74,64 +97,42 @@ bool echrono::Time::operator>= (const echrono::Time& _obj) const { } const echrono::Time& echrono::Time::operator+= (const echrono::Duration& _obj) { - #if defined(__TARGET_OS__MacOs) \ - || defined(__TARGET_OS__IOs) \ - || defined(__TARGET_OS__Web) - std::chrono::microseconds ms = std::chrono::duration_cast(_obj.get()); - m_data += ms; - #else - m_data += _obj.get(); - #endif + m_data += _obj.m_data; return *this; } echrono::Time echrono::Time::operator+ (const echrono::Duration& _obj) const { - echrono::Time time(m_data); - time += _obj; - return time; + echrono::Time tmp(m_data); + tmp += _obj; + return tmp; } const echrono::Time& echrono::Time::operator-= (const echrono::Duration& _obj) { - #if defined(__TARGET_OS__MacOs) \ - || defined(__TARGET_OS__IOs) \ - || defined(__TARGET_OS__Web) - std::chrono::microseconds ms = std::chrono::duration_cast(_obj.get()); - m_data -= ms; - #else - m_data -= _obj.get(); - #endif + m_data -= _obj.m_data; return *this; } echrono::Time echrono::Time::operator- (const echrono::Duration& _obj) const { - echrono::Time time(m_data); - time -= _obj; - return time; + echrono::Time tmp(m_data); + tmp -= _obj; + return tmp; } echrono::Duration echrono::Time::operator- (const echrono::Time& _obj) const { - std::chrono::nanoseconds ns = std::chrono::duration_cast(m_data.time_since_epoch()); - std::chrono::nanoseconds ns2 = std::chrono::duration_cast(_obj.m_data.time_since_epoch()); - echrono::Duration duration(ns); - echrono::Duration duration2(ns2); - return duration - duration2; + return m_data - _obj.m_data; } void echrono::Time::reset() { - m_data = std::chrono::system_clock::time_point(std::chrono::seconds(0)); + m_data = 0; } -int64_t echrono::Time::count() { - std::chrono::nanoseconds ns = std::chrono::duration_cast(m_data.time_since_epoch()); - return ns.count()/1000; -} etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Time& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - int64_t totalSecond = ns.count()/1000000000; - int64_t millisecond = (ns.count()%1000000000)/1000000; - int64_t microsecond = (ns.count()%1000000)/1000; - int64_t nanosecond = ns.count()%1000; + int64_t ns = _obj.get() + int64_t totalSecond = ns/1000000000; + int64_t millisecond = (ns%1000000000)/1000000; + int64_t microsecond = (ns%1000000)/1000; + int64_t nanosecond = ns%1000; //_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns"; int32_t second = totalSecond % 60; int32_t minute = (totalSecond/60)%60; @@ -174,14 +175,10 @@ etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Time& _obj) { namespace etk { template<> etk::String toString(const echrono::Time& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - return etk::toString(ns.count()); + return etk::toString(_obj.get()); + } + template<> etk::UString toUString(const echrono::Time& _obj) { + return etk::toString(_obj.get()); } - #if __CPP_VERSION__ >= 2011 - template<> etk::UString toUString(const echrono::Time& _obj) { - std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); - return etk::toUString(ns.count()); - } - #endif } diff --git a/echrono/Time.hpp b/echrono/Time.hpp index 657f3ce..7b38003 100644 --- a/echrono/Time.hpp +++ b/echrono/Time.hpp @@ -7,7 +7,6 @@ #include #include -#include namespace echrono { class Duration; @@ -16,15 +15,15 @@ namespace echrono { */ class Time { private: - std::chrono::system_clock::time_point m_data; + uint64_t m_data; //!< earth time since Epock public: Time(); //Time(const echrono::Duration& _val) {}; //value in second Time(int64_t _valNano); Time(int64_t _valSec, int64_t _valNano); - Time(const std::chrono::system_clock::time_point& _val); + Time(const echrono::Timet& _val); ~Time() {}; - const std::chrono::system_clock::time_point& get() const { + const int64_t& get() const { return m_data; } /** diff --git a/echrono/echrono.cpp b/echrono/echrono.cpp index 1bd4101..b2dddc8 100644 --- a/echrono/echrono.cpp +++ b/echrono/echrono.cpp @@ -21,7 +21,7 @@ void echrono::init(int _argc, const char** _argv) { if ( data == "-h" || data == "--help") { ECHRONO_PRINT("e-chrono - help : "); - ECHRONO_PRINT(" -h/--help: Dispplay this help"); + ECHRONO_PRINT(" -h/--help: Display this help"); } else if (etk::start_with(data, "--echrono") == true) { ECHRONO_ERROR("Can not parse the argument : '" << data << "'"); }