[DEV] first chrono version

authors.txt

@@ -0,0 +1 @@
+MR Edouard DUPIN <yui.heero@gmail.com>

doxy_echrono.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+import os
+import doxy.module as module
+import doxy.debug as debug
+import doxy.tools as tools
+
+def create(target, module_name):
+	my_module = module.Module(__file__, module_name)
+	my_module.set_version("version.txt")
+	my_module.set_title("E-translate: Ewol runtime translate tool")
+	my_module.set_website("http://atria-soft.github.io/" + module_name)
+	my_module.set_website_sources("http://github.com/atria-soft/" + module_name)
+	"""
+	my_module.add_path([
+	    module_name,
+	    "doc"
+	    ])
+	my_module.add_sample_path([
+	    "sample"
+	    ])
+	"""
+	my_module.add_depend([
+	    'elog',
+	    'etk',
+	    'ejson',
+	    ])
+	my_module.add_exclude_symbols([
+	    '*operator<<*',
+	    ])
+	my_module.add_exclude_file([
+	    'debug.hpp',
+	    ])
+	my_module.add_file_patterns([
+	    '*.hpp',
+	    '*.md',
+	    '*.py',
+	    ])
+	return my_module
+

echrono/Clock.cpp

@@ -0,0 +1,168 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+
+
+#include <echrono/Clock.hpp>
+#include <echrono/Steady.hpp>
+#include <echrono/Duration.hpp>
+#include <echrono/debug.hpp>
+
+echrono::Clock::Clock() {
+	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(0));
+}
+
+echrono::Clock::Clock(int64_t _valNano) {
+	m_data = std::chrono::steady_clock::time_point(std::chrono::nanoseconds(_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(const echrono::Steady& _val) {
+	m_data = _val.get();
+}
+
+echrono::Clock echrono::Clock::now() {
+	return echrono::Clock(std::chrono::steady_clock::now());
+}
+
+const echrono::Clock& echrono::Clock::operator= (const echrono::Clock& _obj) {
+	m_data = _obj.m_data;
+	return *this;
+}
+
+bool echrono::Clock::operator== (const echrono::Clock& _obj) const {
+	return m_data == _obj.m_data;
+}
+
+bool echrono::Clock::operator!= (const echrono::Clock& _obj) const {
+	return m_data != _obj.m_data;
+}
+
+bool echrono::Clock::operator< (const echrono::Clock& _obj) const {
+	return m_data < _obj.m_data;
+}
+
+bool echrono::Clock::operator<= (const echrono::Clock& _obj) const {
+	return m_data <= _obj.m_data;
+}
+
+bool echrono::Clock::operator> (const echrono::Clock& _obj) const {
+	return m_data > _obj.m_data;
+}
+
+bool echrono::Clock::operator>= (const echrono::Clock& _obj) const {
+	return m_data >= _obj.m_data;
+}
+
+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<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);
+	time += _obj;
+	return time;
+}
+
+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<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);
+	time -= _obj;
+	return time;
+}
+
+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());
+	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));
+}
+
+
+std::ostream& echrono::operator <<(std::ostream& _os, const echrono::Clock& _obj) {
+	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_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;
+	//_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns";
+	int32_t second = totalSecond % 60;
+	int32_t minute = (totalSecond/60)%60;
+	int32_t hour = (totalSecond/3600)%24;
+	int32_t day = (totalSecond/(24*3600))%365;
+	int32_t year = totalSecond/(24*3600*365);
+	bool start = false;
+	if (year != 0) {
+		start = true;
+		_os << year << "y ";
+	}
+	if (day != 0 || start == true) {
+		start = true;
+		_os << day << "d ";
+	}
+	if (hour != 0 || start == true) {
+		start = true;
+		_os << hour << "h ";
+	}
+	if (minute != 0 || start == true) {
+		start = true;
+		_os << minute << ":";
+	}
+	if (second != 0 || start == true) {
+		start = true;
+		_os << second << "s ";
+	}
+	if (millisecond != 0 || start == true) {
+		start = true;
+		_os << millisecond << "ms ";
+	}
+	if (microsecond != 0 || start == true) {
+		start = true;
+		_os << microsecond << "us ";
+	}
+	_os << nanosecond << "ns ";
+	return _os;
+}
+
+
+namespace etk {
+	template<> std::string to_string<echrono::Clock>(const echrono::Clock& _obj) {
+		std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+		return etk::to_string(ns.count());
+	}
+	#if __CPP_VERSION__ >= 2011
+		template<> std::u32string to_u32string<echrono::Clock>(const echrono::Clock& _obj) {
+			std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+			return etk::to_u32string(ns.count());
+		}
+	#endif
+}

echrono/Clock.hpp

@@ -0,0 +1,49 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+#include <string>
+#include <etk/types.hpp>
+#include <chrono>
+
+namespace echrono {
+	class Duration;
+	class Steady;
+	/**
+	 * @brief Clock is a compleate virtual clock that is used to virtualize the urrent clock used (can be non real-time, ex:for simulation)
+	 */
+	class Clock {
+		private:
+			std::chrono::steady_clock::time_point 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(const echrono::Steady& _val);
+			~Clock() {};
+			const std::chrono::steady_clock::time_point& get() const {
+				return m_data;
+			}
+			static Clock now();
+			const Clock& operator= (const echrono::Clock& _obj );
+			bool operator== (const echrono::Clock& _obj) const;
+			bool operator!= (const echrono::Clock& _obj) const;
+			bool operator< (const echrono::Clock& _obj) const;
+			bool operator<= (const echrono::Clock& _obj) const;
+			bool operator> (const echrono::Clock& _obj) const;
+			bool operator>= (const echrono::Clock& _obj) const;
+			const Clock& operator+= (const echrono::Duration& _obj);
+			Clock operator+ (const echrono::Duration& _obj) const;
+			const Clock& operator-= (const echrono::Duration& _obj);
+			Clock operator- (const echrono::Duration& _obj) const;
+			Duration operator- (const echrono::Clock& _obj) const;
+			void reset();
+	};
+	std::ostream& operator <<(std::ostream& _os, const echrono::Clock& _obj);
+}
+

echrono/Duration.cpp

@@ -0,0 +1,198 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+
+
+#include <echrono/Time.hpp>
+#include <echrono/Duration.hpp>
+#include <echrono/debug.hpp>
+
+echrono::Duration::Duration() {
+	m_data = std::chrono::nanoseconds(0);
+}
+
+echrono::Duration::Duration(int _val) {
+	m_data = std::chrono::nanoseconds(_val);
+}
+
+echrono::Duration::Duration(int64_t _valSec, int64_t _valNano) {
+	m_data = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(_valSec));
+	m_data += std::chrono::nanoseconds(_valNano);
+}
+
+echrono::Duration::Duration(int64_t _val) {
+	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 += 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) {
+	m_data = _obj.m_data;
+	return *this;
+}
+bool echrono::Duration::operator== (const echrono::Duration& _obj) const {
+	return _obj.m_data == m_data;
+}
+bool echrono::Duration::operator!= (const echrono::Duration& _obj) const {
+	return _obj.m_data != m_data;
+}
+bool echrono::Duration::operator< (const echrono::Duration& _obj) const {
+	return m_data < _obj.m_data;
+}
+bool echrono::Duration::operator<= (const echrono::Duration& _obj) const {
+	return m_data <= _obj.m_data;
+}
+bool echrono::Duration::operator> (const echrono::Duration& _obj) const {
+	return m_data > _obj.m_data;
+}
+bool echrono::Duration::operator>= (const echrono::Duration& _obj) const {
+	return m_data >= _obj.m_data;
+}
+
+float echrono::Duration::toSeconds() const {
+	return float(double(m_data.count()) * 0.0000000001);
+}
+
+const echrono::Duration& echrono::Duration::operator/= (float _value) {
+	m_data = std::chrono::nanoseconds(int64_t(double(m_data.count()) / _value));
+	return *this;
+}
+echrono::Duration echrono::Duration::operator/ (float _value) const {
+	echrono::Duration tmpp(int64_t(double(m_data.count()) / _value));
+	return tmpp;
+}
+
+
+const echrono::Duration& echrono::Duration::operator*= (float _value) {
+	m_data = std::chrono::nanoseconds(int64_t(double(m_data.count()) * _value));
+	return *this;
+}
+echrono::Duration echrono::Duration::operator* (float _value) const {
+	echrono::Duration tmpp(int64_t(double(m_data.count()) * _value));
+	return tmpp;
+}
+
+const echrono::Duration& echrono::Duration::operator+= (const echrono::Duration& _obj) {
+	m_data += _obj.m_data;
+	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;
+}
+
+const echrono::Duration& echrono::Duration::operator-= (const echrono::Duration& _obj) {
+	m_data -= _obj.m_data;
+	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& echrono::Duration::operator++() {
+	m_data += std::chrono::nanoseconds(1);
+	return *this;
+}
+echrono::Duration echrono::Duration::operator++(int _unused) {
+	echrono::Duration result(m_data);
+	m_data += std::chrono::nanoseconds(1);
+	return result;
+}
+echrono::Duration& echrono::Duration::operator--() {
+	m_data -= std::chrono::nanoseconds(1);
+	return *this;
+}
+echrono::Duration echrono::Duration::operator--(int _unused) {
+	m_data -= std::chrono::nanoseconds(1);
+	echrono::Duration result(m_data);
+	return result;
+}
+
+void echrono::Duration::reset() {
+	m_data = std::chrono::nanoseconds(0);
+}
+
+std::ostream& echrono::operator <<(std::ostream& _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;
+	//_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns";
+	int32_t second = totalSecond % 60;
+	int32_t minute = (totalSecond/60)%60;
+	int32_t hour = (totalSecond/3600)%24;
+	int32_t day = (totalSecond/(24*3600))%365;
+	int32_t year = totalSecond/(24*3600*365);
+	bool start = false;
+	if (year != 0) {
+		start = true;
+		_os << year << "y ";
+	}
+	if (day != 0 || start == true) {
+		start = true;
+		_os << day << "d ";
+	}
+	if (hour != 0 || start == true) {
+		start = true;
+		_os << hour << "h ";
+	}
+	if (minute != 0 || start == true) {
+		start = true;
+		_os << minute << ":";
+	}
+	if (second != 0 || start == true) {
+		start = true;
+		_os << second << "s ";
+	}
+	if (millisecond != 0 || start == true) {
+		start = true;
+		_os << millisecond << "ms ";
+	}
+	if (microsecond != 0 || start == true) {
+		start = true;
+		_os << microsecond << "us ";
+	}
+	_os << nanosecond << "ns ";
+	return _os;
+}
+
+namespace etk {
+	template<> std::string to_string<echrono::Duration>(const echrono::Duration& _obj) {
+		return etk::to_string(_obj.count());
+	}
+	#if __CPP_VERSION__ >= 2011
+		template<> std::u32string to_u32string<echrono::Duration>(const echrono::Duration& _obj) {
+			return etk::to_u32string(_obj.count());
+		}
+	#endif
+}
+
+

echrono/Duration.hpp

@@ -0,0 +1,59 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+#include <etk/types.hpp>
+#include <chrono>
+
+namespace echrono {
+	using nanoseconds = std::chrono::nanoseconds;
+	using microseconds = std::chrono::microseconds;
+	using milliseconds = std::chrono::milliseconds;
+	using seconds = std::chrono::seconds;
+	
+	class Duration {
+		private:
+			echrono::nanoseconds 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);
+			~Duration() { };
+			int64_t count() const;
+			const echrono::nanoseconds& get() const {
+				return m_data;
+			}
+			const Duration& operator= (const Duration& _obj);
+			bool operator== (const Duration& _obj) const;
+			bool operator!= (const Duration& _obj) const;
+			bool operator< (const echrono::Duration& _obj) const;
+			bool operator<= (const echrono::Duration& _obj) const;
+			bool operator> (const echrono::Duration& _obj) const;
+			bool operator>= (const echrono::Duration& _obj) const;
+			Duration operator/ (float _value) const;
+			const Duration& operator/= (float _value);
+			Duration operator* (float _value) const;
+			const Duration& operator*= (float _value);
+			const Duration& operator+= (const Duration& _obj);
+			Duration operator+ (const Duration& _obj) const;
+			const Duration& operator-= (const Duration& _obj);
+			Duration operator- (const Duration& _obj) const;
+			Duration& operator++();
+			Duration operator++(int _unused);
+			Duration& operator--();
+			Duration operator--(int _unused);
+			float toSeconds() const;
+			void reset();
+	};
+	std::ostream& operator <<(std::ostream& _os, const echrono::Duration& _obj);
+}
+

echrono/Steady.cpp

@@ -0,0 +1,162 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+
+
+#include <echrono/Steady.hpp>
+#include <echrono/Duration.hpp>
+#include <echrono/debug.hpp>
+
+echrono::Steady::Steady() {
+	m_data = std::chrono::steady_clock::time_point(std::chrono::seconds(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(const std::chrono::steady_clock::time_point& _val) {
+	m_data = _val;
+}
+
+echrono::Steady echrono::Steady::now() {
+	return echrono::Steady(std::chrono::steady_clock::now());
+}
+
+const echrono::Steady& echrono::Steady::operator= (const echrono::Steady& _obj) {
+	m_data = _obj.m_data;
+	return *this;
+}
+
+bool echrono::Steady::operator== (const echrono::Steady& _obj) const {
+	return m_data == _obj.m_data;
+}
+
+bool echrono::Steady::operator!= (const echrono::Steady& _obj) const {
+	return m_data != _obj.m_data;
+}
+
+bool echrono::Steady::operator< (const echrono::Steady& _obj) const {
+	return m_data < _obj.m_data;
+}
+
+bool echrono::Steady::operator<= (const echrono::Steady& _obj) const {
+	return m_data <= _obj.m_data;
+}
+
+bool echrono::Steady::operator> (const echrono::Steady& _obj) const {
+	return m_data > _obj.m_data;
+}
+
+bool echrono::Steady::operator>= (const echrono::Steady& _obj) const {
+	return m_data >= _obj.m_data;
+}
+
+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<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);
+	time += _obj;
+	return time;
+}
+
+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<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);
+	time -= _obj;
+	return time;
+}
+
+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());
+	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));
+}
+
+std::ostream& echrono::operator <<(std::ostream& _os, const echrono::Steady& _obj) {
+	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_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;
+	//_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns";
+	int32_t second = totalSecond % 60;
+	int32_t minute = (totalSecond/60)%60;
+	int32_t hour = (totalSecond/3600)%24;
+	int32_t day = (totalSecond/(24*3600))%365;
+	int32_t year = totalSecond/(24*3600*365);
+	bool start = false;
+	if (year != 0) {
+		start = true;
+		_os << year << "y ";
+	}
+	if (day != 0 || start == true) {
+		start = true;
+		_os << day << "d ";
+	}
+	if (hour != 0 || start == true) {
+		start = true;
+		_os << hour << "h ";
+	}
+	if (minute != 0 || start == true) {
+		start = true;
+		_os << minute << ":";
+	}
+	if (second != 0 || start == true) {
+		start = true;
+		_os << second << "s ";
+	}
+	if (millisecond != 0 || start == true) {
+		start = true;
+		_os << millisecond << "ms ";
+	}
+	if (microsecond != 0 || start == true) {
+		start = true;
+		_os << microsecond << "us ";
+	}
+	_os << nanosecond << "ns ";
+	return _os;
+}
+
+namespace etk {
+	template<> std::string to_string<echrono::Steady>(const echrono::Steady& _obj) {
+		std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+		return etk::to_string(ns.count());
+	}
+	#if __CPP_VERSION__ >= 2011
+		template<> std::u32string to_u32string<echrono::Steady>(const echrono::Steady& _obj) {
+			std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+			return etk::to_u32string(ns.count());
+		}
+	#endif
+}

echrono/Steady.hpp

@@ -0,0 +1,47 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+#include <string>
+#include <etk/types.hpp>
+#include <chrono>
+
+namespace echrono {
+	class Duration;
+	/**
+	 * @brief Steady is a Program start time clock
+	 */
+	class Steady {
+		private:
+			std::chrono::steady_clock::time_point m_data;
+		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 std::chrono::steady_clock::time_point& get() const {
+				return m_data;
+			}
+			static Steady now();
+			const Steady& operator= (const echrono::Steady& _obj );
+			bool operator== (const echrono::Steady& _obj) const;
+			bool operator!= (const echrono::Steady& _obj) const;
+			bool operator< (const echrono::Steady& _obj) const;
+			bool operator<= (const echrono::Steady& _obj) const;
+			bool operator> (const echrono::Steady& _obj) const;
+			bool operator>= (const echrono::Steady& _obj) const;
+			const Steady& operator+= (const echrono::Duration& _obj);
+			Steady operator+ (const echrono::Duration& _obj) const;
+			const Steady& operator-= (const echrono::Duration& _obj);
+			Steady operator- (const echrono::Duration& _obj) const;
+			Duration operator- (const echrono::Steady& _obj) const;
+			void reset();
+	};
+	std::ostream& operator <<(std::ostream& _os, const echrono::Steady& _obj);
+}
+

echrono/Time.cpp

@@ -0,0 +1,164 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+
+
+#include <echrono/Time.hpp>
+#include <echrono/Duration.hpp>
+#include <echrono/debug.hpp>
+
+echrono::Time::Time() {
+	m_data = std::chrono::system_clock::time_point(std::chrono::seconds(0));
+}
+
+echrono::Time::Time(int64_t _valNano) {
+	m_data = std::chrono::system_clock::time_point(std::chrono::nanoseconds(_valNano));
+}
+
+echrono::Time::Time(int64_t _valSec, int64_t _valNano) {
+	m_data = std::chrono::system_clock::time_point(std::chrono::seconds(_valSec));
+	m_data += std::chrono::nanoseconds(_valNano);
+}
+
+echrono::Time::Time(const std::chrono::system_clock::time_point& _val) {
+	m_data = _val;
+}
+
+echrono::Time echrono::Time::now() {
+	return echrono::Time(std::chrono::system_clock::now());
+}
+
+const echrono::Time& echrono::Time::operator= (const echrono::Time& _obj) {
+	m_data = _obj.m_data;
+	return *this;
+}
+
+bool echrono::Time::operator== (const echrono::Time& _obj) const {
+	return m_data == _obj.m_data;
+}
+
+bool echrono::Time::operator!= (const echrono::Time& _obj) const {
+	return m_data != _obj.m_data;
+}
+
+bool echrono::Time::operator< (const echrono::Time& _obj) const {
+	return m_data < _obj.m_data;
+}
+
+bool echrono::Time::operator<= (const echrono::Time& _obj) const {
+	return m_data <= _obj.m_data;
+}
+
+bool echrono::Time::operator> (const echrono::Time& _obj) const {
+	return m_data > _obj.m_data;
+}
+
+bool echrono::Time::operator>= (const echrono::Time& _obj) const {
+	return m_data >= _obj.m_data;
+}
+
+const echrono::Time& echrono::Time::operator+= (const echrono::Duration& _obj) {
+	#if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs)
+		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);
+	time += _obj;
+	return time;
+}
+
+const echrono::Time& echrono::Time::operator-= (const echrono::Duration& _obj) {
+	#if defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__IOs)
+		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);
+	time -= _obj;
+	return time;
+}
+
+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());
+	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));
+}
+
+std::ostream& echrono::operator <<(std::ostream& _os, const echrono::Time& _obj) {
+	std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_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;
+	//_os << totalSecond << "s " << millisecond << "ms " << microsecond << "µs " << nanosecond << "ns";
+	int32_t second = totalSecond % 60;
+	int32_t minute = (totalSecond/60)%60;
+	int32_t hour = (totalSecond/3600)%24;
+	int32_t day = (totalSecond/(24*3600))%365;
+	int32_t year = totalSecond/(24*3600*365);
+	bool start = false;
+	if (year != 0) {
+		start = true;
+		_os << year << "y ";
+	}
+	if (day != 0 || start == true) {
+		start = true;
+		_os << day << "d ";
+	}
+	if (hour != 0 || start == true) {
+		start = true;
+		_os << hour << "h ";
+	}
+	if (minute != 0 || start == true) {
+		start = true;
+		_os << minute << ":";
+	}
+	if (second != 0 || start == true) {
+		start = true;
+		_os << second << "s ";
+	}
+	if (millisecond != 0 || start == true) {
+		start = true;
+		_os << millisecond << "ms ";
+	}
+	if (microsecond != 0 || start == true) {
+		start = true;
+		_os << microsecond << "us ";
+	}
+	_os << nanosecond << "ns ";
+	return _os;
+}
+
+
+namespace etk {
+	template<> std::string to_string<echrono::Time>(const echrono::Time& _obj) {
+		std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+		return etk::to_string(ns.count());
+	}
+	#if __CPP_VERSION__ >= 2011
+		template<> std::u32string to_u32string<echrono::Time>(const echrono::Time& _obj) {
+			std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.get().time_since_epoch());
+			return etk::to_u32string(ns.count());
+		}
+	#endif
+}
+

echrono/Time.hpp

@@ -0,0 +1,47 @@
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+#include <string>
+#include <etk/types.hpp>
+#include <chrono>
+
+namespace echrono {
+	class Duration;
+	/**
+	 * @brief Represent the earth clock (if computer is synchronized)
+	 */
+	class Time {
+		private:
+			std::chrono::system_clock::time_point m_data;
+		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 std::chrono::system_clock::time_point& get() const {
+				return m_data;
+			}
+			static Time now();
+			const Time& operator= (const echrono::Time& _obj );
+			bool operator== (const echrono::Time& _obj) const;
+			bool operator!= (const echrono::Time& _obj) const;
+			bool operator< (const echrono::Time& _obj) const;
+			bool operator<= (const echrono::Time& _obj) const;
+			bool operator> (const echrono::Time& _obj) const;
+			bool operator>= (const echrono::Time& _obj) const;
+			const Time& operator+= (const echrono::Duration& _obj);
+			Time operator+ (const echrono::Duration& _obj) const;
+			const Time& operator-= (const echrono::Duration& _obj);
+			Time operator- (const echrono::Duration& _obj) const;
+			Duration operator- (const echrono::Time& _obj) const;
+			void reset();
+	};
+	std::ostream& operator <<(std::ostream& _os, const echrono::Time& _obj);
+}
+

echrono/debug.cpp

@@ -0,0 +1,12 @@
+/** @file
+ * @author Edouard DUPIN
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+
+#include <echrono/debug.hpp>
+
+int32_t echrono::getLogId() {
+	static int32_t g_val = elog::registerInstance("echrono");
+	return g_val;
+}

echrono/debug.hpp

@@ -0,0 +1,38 @@
+/** @file
+ * @author Edouard DUPIN
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+#include <elog/log.hpp>
+
+namespace echrono {
+	int32_t getLogId();
+};
+#define ECHRONO_BASE(info,data) ELOG_BASE(echrono::getLogId(),info,data)
+
+#define ECHRONO_PRINT(data)         ECHRONO_BASE(-1, data)
+#define ECHRONO_CRITICAL(data)      ECHRONO_BASE(1, data)
+#define ECHRONO_ERROR(data)         ECHRONO_BASE(2, data)
+#define ECHRONO_WARNING(data)       ECHRONO_BASE(3, data)
+#ifdef DEBUG
+	#define ECHRONO_INFO(data)          ECHRONO_BASE(4, data)
+	#define ECHRONO_DEBUG(data)         ECHRONO_BASE(5, data)
+	#define ECHRONO_VERBOSE(data)       ECHRONO_BASE(6, data)
+	#define ECHRONO_TODO(data)          ECHRONO_BASE(4, "TODO : " << data)
+#else
+	#define ECHRONO_INFO(data)          do { } while(false)
+	#define ECHRONO_DEBUG(data)         do { } while(false)
+	#define ECHRONO_VERBOSE(data)       do { } while(false)
+	#define ECHRONO_TODO(data)          do { } while(false)
+#endif
+
+#define ECHRONO_ASSERT(cond,data) \
+	do { \
+		if (!(cond)) { \
+			ECHRONO_CRITICAL(data); \
+			assert(!#cond); \
+		} \
+	} while (0)
+

echrono/echrono.cpp

@@ -0,0 +1,43 @@
+/** @file
+ * @author Edouard DUPIN
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+
+#include <echrono/debug.hpp>
+#include <echrono/echrono.hpp>
+#include <etk/stdTools.hpp>
+
+static int32_t g_isInit = 0;
+
+void echrono::init(int _argc, const char** _argv) {
+	if (g_isInit > 0) {
+		g_isInit++;
+		return;
+	}
+	ECHRONO_INFO("E-chrono system init");
+	for (int32_t iii=0; iii<_argc ; ++iii) {
+		std::string data = _argv[iii];
+		if (    data == "-h"
+		     || data == "--help") {
+			ECHRONO_PRINT("e-chrono - help : ");
+			ECHRONO_PRINT("        -h/--help:               Dispplay this help");
+		} else if (etk::start_with(data, "--echrono") == true) {
+			ECHRONO_ERROR("Can not parse the argument : '" << data << "'");
+		}
+	}
+	g_isInit++;
+}
+
+void echrono::unInit() {
+	if (g_isInit >= 1) {
+		g_isInit--;
+		return;
+	}
+	if (g_isInit == 1) {
+		ECHRONO_INFO("E-chrono system un-init");
+		g_isInit--;
+		return;
+	}
+	ECHRONO_ERROR("E-chrono system un-init (already done before)");
+}

echrono/echrono.hpp

@@ -0,0 +1,19 @@
+/** @file
+ * @author Edouard DUPIN
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+namespace echrono {
+	/**
+	 * @brief Initialize echrono
+	 * @param[in] _argc Number of argument list
+	 * @param[in] _argv List of arguments
+	 */
+	void init(int _argc, const char** _argv);
+	/**
+	 * @brief Un-Initialize echrono
+	 */
+	void unInit();
+}

lutin_echrono.py

@@ -0,0 +1,56 @@
+#!/usr/bin/python
+import lutin.debug as debug
+import lutin.tools as tools
+
+
+def get_type():
+	return "LIBRARY"
+
+def get_desc():
+	return "E-chrono: Ewol chrono wrapper to simplify use of std::chrono (and permit to create a virtual clock)"
+
+def get_licence():
+	return "APACHE-2"
+
+def get_compagny_type():
+	return "com"
+
+def get_compagny_name():
+	return "atria-soft"
+
+def get_maintainer():
+	return "authors.txt"
+
+def get_version():
+	return "version.txt"
+
+def configure(target, my_module):
+	# add extra compilation flags:
+	my_module.add_extra_flags()
+	# add the file to compile:
+	my_module.add_src_file([
+	    'echrono/echrono.cpp',
+	    'echrono/debug.cpp',
+	    'echrono/Duration.cpp',
+	    'echrono/Time.cpp',
+	    'echrono/Steady.cpp',
+	    'echrono/Clock.cpp',
+	    ])
+	my_module.add_header_file([
+	    'echrono/echrono.hpp',
+	    'echrono/Duration.hpp',
+	    'echrono/Time.hpp',
+	    'echrono/Steady.hpp',
+	    'echrono/Clock.hpp',
+	    ])
+	
+	# name of the dependency
+	my_module.add_depend([
+	    'elog',
+	    'etk',
+	    ])
+	
+	my_module.add_path(".")
+	
+	return True
+

version.txt

@@ -0,0 +1 @@
+0.1-dev