From 715fd29b3c05c656aa1e7aa8ad442df08c337e9d Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Fri, 14 Oct 2016 21:13:39 +0200 Subject: [PATCH] [DEV] first chrono version --- authors.txt | 1 + doxy_echrono.py | 39 +++++++++ echrono/Clock.cpp | 168 ++++++++++++++++++++++++++++++++++++ echrono/Clock.hpp | 49 +++++++++++ echrono/Duration.cpp | 198 +++++++++++++++++++++++++++++++++++++++++++ echrono/Duration.hpp | 59 +++++++++++++ echrono/Steady.cpp | 162 +++++++++++++++++++++++++++++++++++ echrono/Steady.hpp | 47 ++++++++++ echrono/Time.cpp | 164 +++++++++++++++++++++++++++++++++++ echrono/Time.hpp | 47 ++++++++++ echrono/debug.cpp | 12 +++ echrono/debug.hpp | 38 +++++++++ echrono/echrono.cpp | 43 ++++++++++ echrono/echrono.hpp | 19 +++++ lutin_echrono.py | 56 ++++++++++++ version.txt | 1 + 16 files changed, 1103 insertions(+) create mode 100644 authors.txt create mode 100644 doxy_echrono.py create mode 100644 echrono/Clock.cpp create mode 100644 echrono/Clock.hpp create mode 100644 echrono/Duration.cpp create mode 100644 echrono/Duration.hpp create mode 100644 echrono/Steady.cpp create mode 100644 echrono/Steady.hpp create mode 100644 echrono/Time.cpp create mode 100644 echrono/Time.hpp create mode 100644 echrono/debug.cpp create mode 100644 echrono/debug.hpp create mode 100644 echrono/echrono.cpp create mode 100644 echrono/echrono.hpp create mode 100644 lutin_echrono.py create mode 100644 version.txt diff --git a/authors.txt b/authors.txt new file mode 100644 index 0000000..75b51f1 --- /dev/null +++ b/authors.txt @@ -0,0 +1 @@ +MR Edouard DUPIN diff --git a/doxy_echrono.py b/doxy_echrono.py new file mode 100644 index 0000000..ba93022 --- /dev/null +++ b/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 + diff --git a/echrono/Clock.cpp b/echrono/Clock.cpp new file mode 100644 index 0000000..b78c940 --- /dev/null +++ b/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 +#include +#include +#include + +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(_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(_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(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; +} + +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(_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(const echrono::Clock& _obj) { + std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); + return etk::to_string(ns.count()); + } + #if __CPP_VERSION__ >= 2011 + template<> std::u32string to_u32string(const echrono::Clock& _obj) { + std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); + return etk::to_u32string(ns.count()); + } + #endif +} diff --git a/echrono/Clock.hpp b/echrono/Clock.hpp new file mode 100644 index 0000000..6d71cde --- /dev/null +++ b/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 +#include +#include + +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); +} + diff --git a/echrono/Duration.cpp b/echrono/Duration.cpp new file mode 100644 index 0000000..807e044 --- /dev/null +++ b/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 +#include +#include + +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::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::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(); +} + +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(const echrono::Duration& _obj) { + return etk::to_string(_obj.count()); + } + #if __CPP_VERSION__ >= 2011 + template<> std::u32string to_u32string(const echrono::Duration& _obj) { + return etk::to_u32string(_obj.count()); + } + #endif +} + + diff --git a/echrono/Duration.hpp b/echrono/Duration.hpp new file mode 100644 index 0000000..63d1316 --- /dev/null +++ b/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 +#include + +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); +} + diff --git a/echrono/Steady.cpp b/echrono/Steady.cpp new file mode 100644 index 0000000..0f7f3e1 --- /dev/null +++ b/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 +#include +#include + +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(_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(_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(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; +} + +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(_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(const echrono::Steady& _obj) { + std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); + return etk::to_string(ns.count()); + } + #if __CPP_VERSION__ >= 2011 + template<> std::u32string to_u32string(const echrono::Steady& _obj) { + std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); + return etk::to_u32string(ns.count()); + } + #endif +} diff --git a/echrono/Steady.hpp b/echrono/Steady.hpp new file mode 100644 index 0000000..8170b6f --- /dev/null +++ b/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 +#include +#include + +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); +} + diff --git a/echrono/Time.cpp b/echrono/Time.cpp new file mode 100644 index 0000000..272c04a --- /dev/null +++ b/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 +#include +#include + +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(_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(_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(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; +} + +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(_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(const echrono::Time& _obj) { + std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); + return etk::to_string(ns.count()); + } + #if __CPP_VERSION__ >= 2011 + template<> std::u32string to_u32string(const echrono::Time& _obj) { + std::chrono::nanoseconds ns = std::chrono::duration_cast(_obj.get().time_since_epoch()); + return etk::to_u32string(ns.count()); + } + #endif +} + diff --git a/echrono/Time.hpp b/echrono/Time.hpp new file mode 100644 index 0000000..7786aaa --- /dev/null +++ b/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 +#include +#include + +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); +} + diff --git a/echrono/debug.cpp b/echrono/debug.cpp new file mode 100644 index 0000000..05f3bc9 --- /dev/null +++ b/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 + +int32_t echrono::getLogId() { + static int32_t g_val = elog::registerInstance("echrono"); + return g_val; +} diff --git a/echrono/debug.hpp b/echrono/debug.hpp new file mode 100644 index 0000000..15ea705 --- /dev/null +++ b/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 + +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) + diff --git a/echrono/echrono.cpp b/echrono/echrono.cpp new file mode 100644 index 0000000..7ec47f2 --- /dev/null +++ b/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 +#include +#include + +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)"); +} diff --git a/echrono/echrono.hpp b/echrono/echrono.hpp new file mode 100644 index 0000000..f71f41e --- /dev/null +++ b/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(); +} diff --git a/lutin_echrono.py b/lutin_echrono.py new file mode 100644 index 0000000..300a871 --- /dev/null +++ b/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 + diff --git a/version.txt b/version.txt new file mode 100644 index 0000000..b4d3330 --- /dev/null +++ b/version.txt @@ -0,0 +1 @@ +0.1-dev \ No newline at end of file