[DEV] remove dependency of std::chrono (not tested)

echrono/Clock.cpp

@@ -11,20 +11,19 @@
 #include <echrono/debug.hpp>
 #include <etk/UString.hpp>
 
-echrono::Clock::Clock() {
+echrono::Clock::Clock() :
-	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0));
+  m_data(0) {
+	
 }
 
-echrono::Clock::Clock(int64_t _valNano) {
+echrono::Clock::Clock(int64_t _valNano) :
-	m_data = std::chrono::steady_clock::time_point(std::chrono::nanoseconds(_valNano));
+  m_data(_valNano) {
+	
 }
 
-echrono::Clock::Clock(int64_t _valSec, int64_t _valNano) {
+echrono::Clock::Clock(int64_t _valSec, int64_t _valNano) :
-	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(_valSec));
+  m_data(_valSec*1000000000LL +_valNano) {
-	m_data += std::chrono::nanoseconds(_valNano);
+	
-}
-echrono::Clock::Clock(const std::chrono::steady_clock::time_point& _val) {
-	m_data = _val;
 }
 
 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)
+	m_data += _obj.get();
-		std::chrono::microseconds ms = std::chrono::duration_cast<std::chrono::microseconds>(_obj.get());
-		m_data += ms;
-	#else
-		m_data += _obj.get();
-	#endif
 	return *this;
 }
 
 echrono::Clock echrono::Clock::operator+ (const echrono::Duration& _obj) const {
-	echrono::Clock time(m_data);
+	echrono::Clock tmp(m_data);
-	time += _obj;
+	tmp += _obj;
-	return time;
+	return tmp;
 }
 
 const echrono::Clock& echrono::Clock::operator-= (const echrono::Duration& _obj) {
-	#if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs)
+	m_data -= _obj.get();
-		std::chrono::microseconds ms = std::chrono::duration_cast<std::chrono::microseconds>(_obj.get());
-		m_data -= ms;
-	#else
-		m_data -= _obj.get();
-	#endif
 	return *this;
 }
 
 echrono::Clock echrono::Clock::operator- (const echrono::Duration& _obj) const {
-	echrono::Clock time(m_data);
+	echrono::Clock tmp(m_data);
-	time -= _obj;
+	tmp -= _obj;
-	return time;
+	return tmp;
 }
 
 echrono::Duration echrono::Clock::operator- (const echrono::Clock& _obj) const {
-	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(m_data.time_since_epoch());
+	return _obj.m_data - m_data;
-	std::chrono::nanoseconds ns2 = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.m_data.time_since_epoch());
-	echrono::Duration duration(ns);
-	echrono::Duration duration2(ns2);
-	return duration - duration2;
 }
 
 void echrono::Clock::reset() {
-	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0));
+	m_data = 0;
-}
-
-int64_t echrono::Clock::count() {
-	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(m_data.time_since_epoch());
-	return ns.count()/1000;
 }
 
 etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Clock& _obj) {
-	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+	int64_t ns = _obj.get()
-	int64_t totalSecond = ns.count()/1000000000;
+	int64_t totalSecond = ns/1000000000;
-	int64_t millisecond = (ns.count()%1000000000)/1000000;
+	int64_t millisecond = (ns%1000000000)/1000000;
-	int64_t microsecond = (ns.count()%1000000)/1000;
+	int64_t microsecond = (ns%1000000)/1000;
-	int64_t nanosecond = ns.count()%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<echrono::Clock>(const echrono::Clock& _obj) {
-		std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+		 ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
-		return etk::toString(ns.count());
+		return etk::toString(_obj.get());
+	}
+	template<> etk::UString toUString<echrono::Clock>(const echrono::Clock& _obj) {
+		return etk::toUString(_obj.get());
 	}
-	#if __CPP_VERSION__ >= 2011
-		template<> etk::UString toUString<echrono::Clock>(const echrono::Clock& _obj) {
-			std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
-			return etk::toUString(ns.count());
-		}
-	#endif
 }

echrono/Clock.hpp

@@ -7,7 +7,6 @@
 
 #include <etk/String.hpp>
 #include <etk/types.hpp>
-#include <chrono>
 
 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(int64_t _valSec, uint32_t _valNano);
-			Clock(const std::chrono::steady_clock::time_point& _val);
+			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;

echrono/Duration.cpp

@@ -10,46 +10,28 @@
 #include <echrono/debug.hpp>
 #include <etk/UString.hpp>
 
-echrono::Duration::Duration() {
+echrono::Duration::Duration() :
-	m_data = std::chrono::nanoseconds(0);
+  m_data(0) {
+	
 }
 
-echrono::Duration::Duration(int _val) {
+echrono::Duration::Duration(int _val) :
-	m_data = std::chrono::nanoseconds(_val);
+  m_data(_val) { {
+	
 }
 
-echrono::Duration::Duration(int64_t _valSec, int64_t _valNano) {
+echrono::Duration::Duration(int64_t _valSec, int64_t _valNano) :
-	m_data = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(_valSec));
+  m_data(_valSec*1000000000LL +_valNano) {
-	m_data += std::chrono::nanoseconds(_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::nanoseconds>(std::chrono::seconds(int64_t(_val)));
+	m_data = int64_t(_val*1000000000.0);
-	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<std::chrono::nanoseconds>(_val);
-}
-
-echrono::Duration::Duration(echrono::microseconds _val) {
-	m_data = std::chrono::duration_cast<std::chrono::nanoseconds>(_val);
-}
-
-echrono::Duration::Duration(echrono::milliseconds _val) {
-	m_data = std::chrono::duration_cast<std::chrono::nanoseconds>(_val);
-}
-
-echrono::Duration::Duration(echrono::seconds _val) {
-	m_data = std::chrono::duration_cast<std::chrono::nanoseconds>(_val);
-}
-
-int64_t echrono::Duration::count() const {
-	return m_data.count();
 }
 
 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 echrono::Duration(int64_t(double(m_data) / _value));
-	return tmpp;
 }
 
 
 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 echrono::Duration(int64_t(double(m_data.count()) * _value));
-	return tmpp;
 }
 
 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);
+	echrono::Duration tmp(m_data);
-	tmpp.m_data += _obj.m_data;
+	tmp.m_data += _obj.m_data;
-	return tmpp;
+	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);
+	echrono::Duration tmp(m_data);
-	tmpp.m_data -= _obj.m_data;
+	tmp.m_data -= _obj.m_data;
-	return tmpp;
+	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);
+	echrono::Duration tmp(m_data);
-	m_data += std::chrono::nanoseconds(1);
+	m_data++;
-	return result;
+	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 tmp(m_data);
-	echrono::Duration result(m_data);
+	m_data--;
-	return result;
+	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 totalSecond = _obj.get()/1000000000;
-	int64_t millisecond = (_obj.count()%1000000000)/1000000;
+	int64_t millisecond = (_obj.get()%1000000000)/1000000;
-	int64_t microsecond = (_obj.count()%1000000)/1000;
+	int64_t microsecond = (_obj.get()%1000000)/1000;
-	int64_t nanosecond = _obj.count()%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<echrono::Duration>(const echrono::Duration& _obj) {
-		return etk::toString(_obj.count());
+		return etk::toString(_obj.get());
+	}
+	template<> etk::UString toUString<echrono::Duration>(const echrono::Duration& _obj) {
+		return etk::toUString(_obj.get());
 	}
-	#if __CPP_VERSION__ >= 2011
-		template<> etk::UString toUString<echrono::Duration>(const echrono::Duration& _obj) {
-			return etk::toUString(_obj.count());
-		}
-	#endif
 }
 
 

echrono/Duration.hpp

@@ -9,27 +9,43 @@
 #include <chrono>
 
 namespace echrono {
-	using nanoseconds = std::chrono::nanoseconds;
+	template<ECHRONO_FACTOR>
-	using microseconds = std::chrono::microseconds;
+	class genericOffsetTime {
-	using milliseconds = std::chrono::milliseconds;
+		private:
-	using seconds = std::chrono::seconds;
+			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);
+			template<ECHRONO_FACTOR>
-			Duration(echrono::microseconds _val);
+			Duration(const genericOffsetTime<ECHRONO_FACTOR>& _val) {
-			Duration(echrono::milliseconds _val);
+				m_data = _val.get();
-			Duration(echrono::seconds _val);
+			}
 			~Duration() { };
 			int64_t count() const;
-			const echrono::nanoseconds& get() const {
+			const int64_t& get() const {
 				return m_data;
 			}
 			const Duration& operator= (const Duration& _obj);

echrono/Steady.cpp

@@ -9,18 +9,53 @@
 #include <echrono/Duration.hpp>
 #include <echrono/debug.hpp>
 #include <etk/UString.hpp>
+#include <time.h>
 
-echrono::Steady::Steady() {
+static int64_t getTime() {
-	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0));
+	#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) {
+echrono::Steady::Steady(int64_t _valSec, int64_t _valNano) :
-	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(_valSec));
+  m_data(_valSec*1000000000LL +_valNano) {
-	m_data += std::chrono::nanoseconds(_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)
+	m_data += _obj.get();
-		std::chrono::microseconds ms = std::chrono::duration_cast<std::chrono::microseconds>(_obj.get());
-		m_data += ms;
-	#else
-		m_data += _obj.get();
-	#endif
 	return *this;
 }
 
 echrono::Steady echrono::Steady::operator+ (const echrono::Duration& _obj) const {
-	echrono::Steady time(m_data);
+	echrono::Steady tmp(m_data);
-	time += _obj;
+	tmp += _obj;
-	return time;
+	return tmp;
 }
 
 const echrono::Steady& echrono::Steady::operator-= (const echrono::Duration& _obj) {
-	#if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs)
+	m_data -= _obj.get();
-		std::chrono::microseconds ms = std::chrono::duration_cast<std::chrono::microseconds>(_obj.get());
-		m_data -= ms;
-	#else
-		m_data -= _obj.get();
-	#endif
 	return *this;
 }
 
 echrono::Steady echrono::Steady::operator- (const echrono::Duration& _obj) const {
-	echrono::Steady time(m_data);
+	echrono::Steady tmp(m_data);
-	time -= _obj;
+	tmp -= _obj;
-	return time;
+	return tmp;
 }
 
 echrono::Duration echrono::Steady::operator- (const echrono::Steady& _obj) const {
-	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(m_data.time_since_epoch());
+	return m_data - _obj.m_data;
-	std::chrono::nanoseconds ns2 = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.m_data.time_since_epoch());
-	echrono::Duration duration(ns);
-	echrono::Duration duration2(ns2);
-	return duration - duration2;
 }
 
 void echrono::Steady::reset() {
-	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0));
+	m_data = 0;
-}
-
-int64_t echrono::Steady::count() {
-	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(m_data.time_since_epoch());
-	return ns.count()/1000;
 }
 
 etk::Stream& echrono::operator <<(etk::Stream& _os, const echrono::Steady& _obj) {
-	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+	int64_t ns = obj.get();
-	int64_t totalSecond = ns.count()/1000000000;
+	int64_t totalSecond = ns/1000000000;
-	int64_t millisecond = (ns.count()%1000000000)/1000000;
+	int64_t millisecond = (ns%1000000000)/1000000;
-	int64_t microsecond = (ns.count()%1000000)/1000;
+	int64_t microsecond = (ns%1000000)/1000;
-	int64_t nanosecond = ns.count()%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<echrono::Steady>(const echrono::Steady& _obj) {
-		std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+		return etk::toString(_obj.get());
-		return etk::toString(ns.count());
+	}
+	template<> etk::UString toUString<echrono::Steady>(const echrono::Steady& _obj) {
+		return etk::toUString(_obj.get());
 	}
-	#if __CPP_VERSION__ >= 2011
-		template<> etk::UString toUString<echrono::Steady>(const echrono::Steady& _obj) {
-			std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
-			return etk::toUString(ns.count());
-		}
-	#endif
 }

echrono/Steady.hpp

@@ -7,7 +7,6 @@
 
 #include <etk/String.hpp>
 #include <etk/types.hpp>
-#include <chrono>
 
 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;
 			}
 			/**

echrono/Time.cpp

@@ -11,37 +11,60 @@
 #include <etk/UString.hpp>
 #include <etk/stdTools.hpp>
 
-echrono::Time::Time() {
+static int64_t getTime() {
-	m_data = std::chrono::system_clock::time_point(std::chrono::seconds(0));
+	#if defined(__TARGET_OS__Android)
-}
+		struct timevalnow;
-
+		gettimeofday(&now, nullptr);
-echrono::Time::Time(int64_t _valNano) {
+		return int64_t(now.tv_sec)*1000000LL + int64_t(now.tv_usec);
-	#if    defined(__TARGET_OS__MacOs) \
+	#elif    defined(__TARGET_OS__Web) \
-	    or defined(__TARGET_OS__IOs) \
+	      || defined(__TARGET_OS__Linux) \
-	    or defined(__TARGET_OS__Web)
+	      || defined(__TARGET_OS__buildroot)
-		m_data = std::chrono::system_clock::time_point(std::chrono::milliseconds(_valNano/1000));
+		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) {
+echrono::Time::Time() :
-	m_data = std::chrono::system_clock::time_point(std::chrono::seconds(_valSec));
+  m_data(0) {
-	#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(const std::chrono::system_clock::time_point& _val) {
+echrono::Time::Time(int64_t _valNano) :
-	m_data = _val;
+  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) \
+	m_data += _obj.m_data;
-	    || defined(__TARGET_OS__IOs) \
-	    || defined(__TARGET_OS__Web)
-		std::chrono::microseconds ms = std::chrono::duration_cast<std::chrono::microseconds>(_obj.get());
-		m_data += ms;
-	#else
-		m_data += _obj.get();
-	#endif
 	return *this;
 }
 
 echrono::Time echrono::Time::operator+ (const echrono::Duration& _obj) const {
-	echrono::Time time(m_data);
+	echrono::Time tmp(m_data);
-	time += _obj;
+	tmp += _obj;
-	return time;
+	return tmp;
 }
 
 const echrono::Time& echrono::Time::operator-= (const echrono::Duration& _obj) {
-	#if    defined(__TARGET_OS__MacOs) \
+	m_data -= _obj.m_data;
-	    || defined(__TARGET_OS__IOs) \
-	    || defined(__TARGET_OS__Web)
-		std::chrono::microseconds ms = std::chrono::duration_cast<std::chrono::microseconds>(_obj.get());
-		m_data -= ms;
-	#else
-		m_data -= _obj.get();
-	#endif
 	return *this;
 }
 
 echrono::Time echrono::Time::operator- (const echrono::Duration& _obj) const {
-	echrono::Time time(m_data);
+	echrono::Time tmp(m_data);
-	time -= _obj;
+	tmp -= _obj;
-	return time;
+	return tmp;
 }
 
 echrono::Duration echrono::Time::operator- (const echrono::Time& _obj) const {
-	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(m_data.time_since_epoch());
+	return m_data - _obj.m_data;
-	std::chrono::nanoseconds ns2 = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.m_data.time_since_epoch());
-	echrono::Duration duration(ns);
-	echrono::Duration duration2(ns2);
-	return duration - duration2;
 }
 
 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<std::chrono::nanoseconds>(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<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+	int64_t ns = _obj.get()
-	int64_t totalSecond = ns.count()/1000000000;
+	int64_t totalSecond = ns/1000000000;
-	int64_t millisecond = (ns.count()%1000000000)/1000000;
+	int64_t millisecond = (ns%1000000000)/1000000;
-	int64_t microsecond = (ns.count()%1000000)/1000;
+	int64_t microsecond = (ns%1000000)/1000;
-	int64_t nanosecond = ns.count()%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<echrono::Time>(const echrono::Time& _obj) {
-		std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+		return etk::toString(_obj.get());
-		return etk::toString(ns.count());
+	}
+	template<> etk::UString toUString<echrono::Time>(const echrono::Time& _obj) {
+		return etk::toString(_obj.get());
 	}
-	#if __CPP_VERSION__ >= 2011
-		template<> etk::UString toUString<echrono::Time>(const echrono::Time& _obj) {
-			std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
-			return etk::toUString(ns.count());
-		}
-	#endif
 }
 

echrono/Time.hpp

@@ -7,7 +7,6 @@
 
 #include <etk/String.hpp>
 #include <etk/types.hpp>
-#include <chrono>
 
 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;
 			}
 			/**

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 << "'");
 		}