From 81b749caa2ad38a17987c426568260a6a5f2c152 Mon Sep 17 00:00:00 2001 From: peri4 Date: Fri, 25 Mar 2022 17:47:41 +0300 Subject: [PATCH] doc, pitime.h decomposition --- README.md | 2 +- libs/main/core/pibytearray.h | 1 + libs/main/core/pichar.h | 1 + libs/main/core/pichunkstream.h | 1 + libs/main/core/picli.h | 1 + libs/main/core/picollection.h | 1 + libs/main/core/picout.h | 1 + libs/main/core/pidatetime.cpp | 360 +++++++++++++++++++++ libs/main/core/pidatetime.h | 129 ++++++++ libs/main/core/piflags.h | 1 + libs/main/core/piincludes.h | 6 + libs/main/core/piinit.h | 1 + libs/main/core/piobject.h | 1 + libs/main/core/piobject_macros.h | 7 +- libs/main/core/pipropertystorage.h | 1 + libs/main/core/pistring.h | 7 +- libs/main/core/pistring_std.h | 7 +- libs/main/core/pistringlist.h | 1 + libs/main/core/pisystemtime.cpp | 231 ++++++++++++++ libs/main/core/pisystemtime.h | 245 ++++++++++++++ libs/main/core/pitime.cpp | 496 +---------------------------- libs/main/core/pitime.h | 337 +------------------- libs/main/core/pitime_win.h | 7 +- libs/main/core/pivariant.h | 7 +- libs/main/core/pivariantsimple.h | 7 +- libs/main/core/pivarianttypes.h | 7 +- 26 files changed, 1025 insertions(+), 841 deletions(-) create mode 100644 libs/main/core/pidatetime.cpp create mode 100644 libs/main/core/pidatetime.h create mode 100644 libs/main/core/pisystemtime.cpp create mode 100644 libs/main/core/pisystemtime.h diff --git a/README.md b/README.md index 80da2824..cfe6905a 100644 --- a/README.md +++ b/README.md @@ -35,4 +35,4 @@ You should add ${} to your target. [Online documentation](https://shs.tools/pip/html/en/index.html) -[Документация на Русском языке](https://shs.tools/pip/html/ru/index.html) +[Онлайн документация](https://shs.tools/pip/html/ru/index.html) diff --git a/libs/main/core/pibytearray.h b/libs/main/core/pibytearray.h index dedfc15c..e7a93976 100644 --- a/libs/main/core/pibytearray.h +++ b/libs/main/core/pibytearray.h @@ -1,4 +1,5 @@ /*! \file pibytearray.h + * \ingroup Core * \~\brief * \~english Byte array * \~russian Байтовый массив diff --git a/libs/main/core/pichar.h b/libs/main/core/pichar.h index 43982d99..affd0385 100644 --- a/libs/main/core/pichar.h +++ b/libs/main/core/pichar.h @@ -1,4 +1,5 @@ /*! \file pichar.h + * \ingroup Core * \~\brief * \~english Single string character * \~russian Один символ строки diff --git a/libs/main/core/pichunkstream.h b/libs/main/core/pichunkstream.h index 7f1fa2ce..ddc6ee12 100644 --- a/libs/main/core/pichunkstream.h +++ b/libs/main/core/pichunkstream.h @@ -1,4 +1,5 @@ /*! \file pichunkstream.h + * \ingroup Core * \~\brief * \~english Binary markup de/serializator stream * \~russian Бинарный поток для де/сериализации с разметкой diff --git a/libs/main/core/picli.h b/libs/main/core/picli.h index c2792877..4c1377a8 100644 --- a/libs/main/core/picli.h +++ b/libs/main/core/picli.h @@ -1,4 +1,5 @@ /*! \file picli.h + * \ingroup Core * \~\brief * \~english Command-Line parser * \~russian Парсер командной строки diff --git a/libs/main/core/picollection.h b/libs/main/core/picollection.h index 29310def..e60d12f3 100644 --- a/libs/main/core/picollection.h +++ b/libs/main/core/picollection.h @@ -1,4 +1,5 @@ /*! \file picollection.h + * \ingroup Core * \~\brief * \~english Custom elements collection * \~russian diff --git a/libs/main/core/picout.h b/libs/main/core/picout.h index eed2f1ff..3eb0e3df 100644 --- a/libs/main/core/picout.h +++ b/libs/main/core/picout.h @@ -1,4 +1,5 @@ /*! \file picout.h + * \ingroup Core * \~\brief * \~english Universal output to console class * \~russian Универсальный вывод в консоль diff --git a/libs/main/core/pidatetime.cpp b/libs/main/core/pidatetime.cpp new file mode 100644 index 00000000..e991f93d --- /dev/null +++ b/libs/main/core/pidatetime.cpp @@ -0,0 +1,360 @@ +/* + PIP - Platform Independent Primitives + Timer + Ivan Pelipenko peri4ko@yandex.ru + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + +#include "piincludes_p.h" +#include "pidatetime.h" +#include +#ifdef ARDUINO +# include +#endif +#ifdef MAC_OS +//# include +//# include +# include +//# include +#endif +#ifdef MICRO_PIP +# include +#endif + +//! \addtogroup Core +//! \{ +//! \class PISystemTime pitime.h +//! \brief +//! \~english System time with nanosecond precision +//! \~russian Системное время с точностью до наносекунд +//! +//! \~english \section PISystemTime_sec0 Synopsis +//! \~russian \section PISystemTime_sec0 Краткий обзор +//! \~english +//! +//! \~russian +//! +//! \~english \section PISystemTime_sec1 Example +//! \~russian \section PISystemTime_sec1 Пример +//! \~\snippet pitimer.cpp system_time +//! +//! \} + + + + +bool operator ==(const PITime & t0, const PITime & t1) { + return (t0.hours == t1.hours && t0.minutes == t1.minutes && t0.seconds == t1.seconds); +} + +#include +bool operator <(const PITime & t0, const PITime & t1) { + std::map m; + m.at + if (t0.hours == t1.hours) { + if (t0.minutes == t1.minutes) { + return t0.seconds < t1.seconds; + } else return t0.minutes < t1.minutes; + } else return t0.hours < t1.hours; +} + + +bool operator >(const PITime & t0, const PITime & t1) { + if (t0.hours == t1.hours) { + if (t0.minutes == t1.minutes) { + return t0.seconds > t1.seconds; + } else return t0.minutes > t1.minutes; + } else return t0.hours > t1.hours; +} + +bool operator ==(const PIDate & t0, const PIDate & t1) { + return (t0.year == t1.year && t0.month == t1.month && t0.day == t1.day); +} + + +bool operator <(const PIDate & t0, const PIDate & t1) { + if (t0.year == t1.year) { + if (t0.month == t1.month) { + return t0.day < t1.day; + } else return t0.month < t1.month; + } else return t0.year < t1.year; +} + + +bool operator >(const PIDate & t0, const PIDate & t1) { + if (t0.year == t1.year) { + if (t0.month == t1.month) { + return t0.day > t1.day; + } else return t0.month > t1.month; + } else return t0.year > t1.year; +} + +bool operator ==(const PIDateTime & t0, const PIDateTime & t1) { + return (t0.year == t1.year && t0.month == t1.month && t0.day == t1.day && + t0.hours == t1.hours && t0.minutes == t1.minutes && t0.seconds == t1.seconds); +} + + +bool operator <(const PIDateTime & t0, const PIDateTime & t1) { + if (t0.year == t1.year) { + if (t0.month == t1.month) { + if (t0.day == t1.day) { + if (t0.hours == t1.hours) { + if (t0.minutes == t1.minutes) { + return t0.seconds < t1.seconds; + } else return t0.minutes < t1.minutes; + } else return t0.hours < t1.hours; + } else return t0.day < t1.day; + } else return t0.month < t1.month; + } else return t0.year < t1.year; +} + + +bool operator >(const PIDateTime & t0, const PIDateTime & t1) { + if (t0.year == t1.year) { + if (t0.month == t1.month) { + if (t0.day == t1.day) { + if (t0.hours == t1.hours) { + if (t0.minutes == t1.minutes) { + return t0.seconds > t1.seconds; + } else return t0.minutes > t1.minutes; + } else return t0.hours > t1.hours; + } else return t0.day > t1.day; + } else return t0.month > t1.month; + } else return t0.year > t1.year; +} + + +PISystemTime PITime::toSystemTime() const { + return PISystemTime((hours * 60. + minutes) * 60. + seconds, milliseconds * 1000.); +} + + +PITime PITime::current() { + time_t rt = ::time(0); + tm * pt = localtime(&rt); + PITime t; + t.seconds = pt->tm_sec; + t.minutes = pt->tm_min; + t.hours = pt->tm_hour; + return t; +} + + +PITime PITime::fromSystemTime(const PISystemTime & st) { + double s = st.toSeconds(); + int v = s; + PITime ret; + ret.milliseconds = (s - v) * 1000; + ret.seconds = v % 60; v = (v - ret.seconds) / 60; + ret.minutes = v % 60; v = (v - ret.minutes) / 60; + ret.hours = v; + return ret; +} + + +PIDate PIDate::current() { + time_t rt = ::time(0); + tm * pt = localtime(&rt); + PIDate d; + d.day = pt->tm_mday; + d.month = pt->tm_mon + 1; + d.year = pt->tm_year + 1900; + return d; +} + + +PIDateTime PIDateTime::current() { + time_t rt = ::time(0); + tm * pt = localtime(&rt); + PIDateTime dt; + dt.milliseconds = 0; + dt.seconds = pt->tm_sec; + dt.minutes = pt->tm_min; + dt.hours = pt->tm_hour; + dt.day = pt->tm_mday; + dt.month = pt->tm_mon + 1; + dt.year = pt->tm_year + 1900; + return dt; +} + + + + +PIString PITime::toString(const PIString & format) const { + PIString ts = format; + ts.replace("hh", PIString::fromNumber(hours).expandLeftTo(2, '0')); + ts.replace("h", PIString::fromNumber(hours)); + ts.replace("mm", PIString::fromNumber(minutes).expandLeftTo(2, '0')); + ts.replace("m", PIString::fromNumber(minutes)); + ts.replace("ss", PIString::fromNumber(seconds).expandLeftTo(2, '0')); + ts.replace("s", PIString::fromNumber(seconds)); + ts.replace("zzz", PIString::fromNumber(milliseconds).expandLeftTo(3, '0')); + ts.replace("zz", PIString::fromNumber(milliseconds).expandLeftTo(2, '0')); + ts.replace("z", PIString::fromNumber(milliseconds)); + return ts; +} + + +PIString PIDate::toString(const PIString & format) const { + PIString ts = format; + ts.replace("yyyy", PIString::fromNumber(year).expandLeftTo(4, '0')); + ts.replace("yy", PIString::fromNumber(year).right(2)); + ts.replace("y", PIString::fromNumber(year).right(1)); + ts.replace("MM", PIString::fromNumber(month).expandLeftTo(2, '0')); + ts.replace("M", PIString::fromNumber(month)); + ts.replace("dd", PIString::fromNumber(day).expandLeftTo(2, '0')); + ts.replace("d", PIString::fromNumber(day)); + return ts; +} + + +PIString PIDateTime::toString(const PIString & format) const { + PIString ts = format; + ts.replace("yyyy", PIString::fromNumber(year).expandLeftTo(4, '0')); + ts.replace("yy", PIString::fromNumber(year).right(2)); + ts.replace("y", PIString::fromNumber(year).right(1)); + ts.replace("MM", PIString::fromNumber(month).expandLeftTo(2, '0')); + ts.replace("M", PIString::fromNumber(month)); + ts.replace("dd", PIString::fromNumber(day).expandLeftTo(2, '0')); + ts.replace("d", PIString::fromNumber(day)); + ts.replace("hh", PIString::fromNumber(hours).expandLeftTo(2, '0')); + ts.replace("h", PIString::fromNumber(hours)); + ts.replace("mm", PIString::fromNumber(minutes).expandLeftTo(2, '0')); + ts.replace("m", PIString::fromNumber(minutes)); + ts.replace("ss", PIString::fromNumber(seconds).expandLeftTo(2, '0')); + ts.replace("s", PIString::fromNumber(seconds)); + ts.replace("zzz", PIString::fromNumber(milliseconds).expandLeftTo(3, '0')); + ts.replace("zz", PIString::fromNumber(milliseconds).expandLeftTo(2, '0')); + ts.replace("z", PIString::fromNumber(milliseconds)); + return ts; +} + + +time_t PIDateTime::toSecondSinceEpoch() const { + tm pt; + memset(&pt, 0, sizeof(pt)); + pt.tm_sec = seconds; + pt.tm_min = minutes; + pt.tm_hour = hours; + pt.tm_mday = day; + pt.tm_mon = month - 1; +#ifdef WINDOWS + pt.tm_year = piMaxi(year - 1900, 70); +#else + pt.tm_year = piMaxi(year - 1900, 0); +#endif + return mktime(&pt); +} + + +PIDateTime PIDateTime::fromSecondSinceEpoch(const time_t sec) { + tm * pt = localtime(&sec); + PIDateTime dt; + dt.seconds = pt->tm_sec; + dt.minutes = pt->tm_min; + dt.hours = pt->tm_hour; + dt.day = pt->tm_mday; + dt.month = pt->tm_mon + 1; + dt.year = pt->tm_year + 1900; + return dt; + +} + + +PIString time2string(const PITime & time, const PIString & format) { + PIString ts = format; + ts.replace("hh", PIString::fromNumber(time.hours).expandLeftTo(2, '0')); + ts.replace("h", PIString::fromNumber(time.hours)); + ts.replace("mm", PIString::fromNumber(time.minutes).expandLeftTo(2, '0')); + ts.replace("m", PIString::fromNumber(time.minutes)); + ts.replace("ss", PIString::fromNumber(time.seconds).expandLeftTo(2, '0')); + ts.replace("s", PIString::fromNumber(time.seconds)); + return ts; +} + + +PIString date2string(const PIDate & date, const PIString & format) { + PIString ts = format; + ts.replace("yyyy", PIString::fromNumber(date.year).expandLeftTo(4, '0')); + ts.replace("yy", PIString::fromNumber(date.year).right(2)); + ts.replace("y", PIString::fromNumber(date.year).right(1)); + ts.replace("MM", PIString::fromNumber(date.month).expandLeftTo(2, '0')); + ts.replace("M", PIString::fromNumber(date.month)); + ts.replace("dd", PIString::fromNumber(date.day).expandLeftTo(2, '0')); + ts.replace("d", PIString::fromNumber(date.day)); + return ts; +} + + +PIString datetime2string(const PIDateTime & date, const PIString & format) { + PIString ts = format; + ts.replace("hh", PIString::fromNumber(date.hours).expandLeftTo(2, '0')); + ts.replace("h", PIString::fromNumber(date.hours)); + ts.replace("mm", PIString::fromNumber(date.minutes).expandLeftTo(2, '0')); + ts.replace("m", PIString::fromNumber(date.minutes)); + ts.replace("ss", PIString::fromNumber(date.seconds).expandLeftTo(2, '0')); + ts.replace("s", PIString::fromNumber(date.seconds)); + ts.replace("yyyy", PIString::fromNumber(date.year).expandLeftTo(4, '0')); + ts.replace("yy", PIString::fromNumber(date.year).right(2)); + ts.replace("y", PIString::fromNumber(date.year).right(1)); + ts.replace("MM", PIString::fromNumber(date.month).expandLeftTo(2, '0')); + ts.replace("M", PIString::fromNumber(date.month)); + ts.replace("dd", PIString::fromNumber(date.day).expandLeftTo(2, '0')); + ts.replace("d", PIString::fromNumber(date.day)); + return ts; +} + + + + +PICout operator <<(PICout s, const PITime & v) { + s.space(); + s.setControl(0, true); + s << "PITime(" << v.hours << ":"; + s << PIString::fromNumber(v.minutes).expandLeftTo(2, '0') << ":"; + s << PIString::fromNumber(v.seconds).expandLeftTo(2, '0') << ":"; + s << PIString::fromNumber(v.milliseconds).expandLeftTo(3, '0') << ")"; + s.restoreControl(); + return s; +} + + +PICout operator <<(PICout s, const PIDate & v) { + s.space(); + s.setControl(0, true); + s << "PIDate(" << v.day << "-"; + s << PIString::fromNumber(v.month).expandLeftTo(2, '0') << "-"; + s << v.year << ")"; + s.restoreControl(); + return s; +} + + +PICout operator <<(PICout s, const PIDateTime & v) { + s.space(); + s.setControl(0, true); + s << "PIDateTime("; + s << v.day << "-"; + s << PIString::fromNumber(v.month).expandLeftTo(2, '0') << "-"; + s << v.year << " "; + s << v.hours << ":"; + s << PIString::fromNumber(v.minutes).expandLeftTo(2, '0') << ":"; + s << PIString::fromNumber(v.seconds).expandLeftTo(2, '0') << ":"; + s << PIString::fromNumber(v.milliseconds).expandLeftTo(3, '0') << ")"; + s.restoreControl(); + return s; +} + diff --git a/libs/main/core/pidatetime.h b/libs/main/core/pidatetime.h new file mode 100644 index 00000000..4a4b85d3 --- /dev/null +++ b/libs/main/core/pidatetime.h @@ -0,0 +1,129 @@ +/*! \file pidatetime.h + * \ingroup Core + * \~\brief + * \~english Time and date structs + * \~russian Типы времени и даты +*/ +/* + PIP - Platform Independent Primitives + Time and date structs + Ivan Pelipenko peri4ko@yandex.ru + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + +#ifndef PIDATETIME_H +#define PIDATETIME_H + + +#include "pisystemtime.h" + + +struct PIP_EXPORT PITime { + PITime(int hours_ = 0, int minutes_ = 0, int seconds_ = 0, int milliseconds_ = 0): hours(hours_), minutes(minutes_), seconds(seconds_), milliseconds(milliseconds_) {;} + int hours; + int minutes; + int seconds; + int milliseconds; + PIString toString(const PIString & format = "h:mm:ss") const; + PISystemTime toSystemTime() const; + static PITime current(); + static PITime fromSystemTime(const PISystemTime & st); +}; + +PIP_EXPORT bool operator ==(const PITime & t0, const PITime & t1); +PIP_EXPORT bool operator <(const PITime & t0, const PITime & t1); +PIP_EXPORT bool operator >(const PITime & t0, const PITime & t1); +inline bool operator !=(const PITime & t0, const PITime & t1) {return !(t0 == t1);} +inline bool operator <=(const PITime & t0, const PITime & t1) {return !(t0 > t1);} +inline bool operator >=(const PITime & t0, const PITime & t1) {return !(t0 < t1);} + +//! \relatesalso PICout +//! \~english \brief Output operator to PICout +//! \~russian \brief Оператор вывода в PICout +PIP_EXPORT PICout operator <<(PICout s, const PITime & v); + + + + +struct PIP_EXPORT PIDate { + PIDate(int year_ = 0, int month_ = 0, int day_ = 0): year(year_), month(month_), day(day_) {;} + int year; + int month; + int day; + PIString toString(const PIString & format = "d.MM.yyyy") const; + static PIDate current(); +}; + +PIP_EXPORT bool operator ==(const PIDate & t0, const PIDate & t1); +PIP_EXPORT bool operator <(const PIDate & t0, const PIDate & t1); +PIP_EXPORT bool operator >(const PIDate & t0, const PIDate & t1); +inline bool operator !=(const PIDate & t0, const PIDate & t1) {return !(t0 == t1);} +inline bool operator <=(const PIDate & t0, const PIDate & t1) {return !(t0 > t1);} +inline bool operator >=(const PIDate & t0, const PIDate & t1) {return !(t0 < t1);} + +//! \relatesalso PICout +//! \~english \brief Output operator to PICout +//! \~russian \brief Оператор вывода в PICout +PIP_EXPORT PICout operator <<(PICout s, const PIDate & v); + + + + +struct PIP_EXPORT PIDateTime { + PIDateTime() {year = month = day = hours = minutes = seconds = milliseconds = 0;} + PIDateTime(const PITime & time) {year = month = day = 0; hours = time.hours; minutes = time.minutes; seconds = time.seconds; milliseconds = time.milliseconds;} + PIDateTime(const PIDate & date) {year = date.year; month = date.month; day = date.day; hours = minutes = seconds = milliseconds = 0;} + PIDateTime(const PIDate & date, const PITime & time) {year = date.year; month = date.month; day = date.day; hours = time.hours; minutes = time.minutes; seconds = time.seconds; milliseconds = time.milliseconds;} + int year; + int month; + int day; + int hours; + int minutes; + int seconds; + int milliseconds; + PIDateTime normalized() const {return PIDateTime::fromSecondSinceEpoch(toSecondSinceEpoch());} + void normalize() {*this = normalized();} + PIString toString(const PIString & format = "h:mm:ss d.MM.yyyy") const; + time_t toSecondSinceEpoch() const; + PISystemTime toSystemTime() const {return PISystemTime(int(toSecondSinceEpoch()), milliseconds * 1000000);} + PIDate date() const {return PIDate(year, month, day);} + PITime time() const {return PITime(hours, minutes, seconds, milliseconds);} + void setDate(const PIDate & d) {year = d.year; month = d.month; day = d.day;} + void setTime(const PITime & t) {hours = t.hours; minutes = t.minutes; seconds = t.seconds; milliseconds = t.milliseconds;} + void operator +=(const PIDateTime & d1) {year += d1.year; month += d1.month; day += d1.day; hours += d1.hours; minutes += d1.minutes; seconds += d1.seconds; normalize();} + void operator -=(const PIDateTime & d1) {year -= d1.year; month -= d1.month; day -= d1.day; hours -= d1.hours; minutes -= d1.minutes; seconds -= d1.seconds; normalize();} + static PIDateTime fromSecondSinceEpoch(const time_t sec); + static PIDateTime fromSystemTime(const PISystemTime & st) {PIDateTime dt = fromSecondSinceEpoch(st.seconds); dt.milliseconds = piClampi(st.nanoseconds / 1000000, 0, 999); return dt;} + static PIDateTime current(); +}; + +inline PIDateTime operator +(const PIDateTime & d0, const PIDateTime & d1) {PIDateTime td = d0; td += d1; return td.normalized();} +inline PIDateTime operator -(const PIDateTime & d0, const PIDateTime & d1) {PIDateTime td = d0; td -= d1; return td.normalized();} +PIP_EXPORT bool operator ==(const PIDateTime & t0, const PIDateTime & t1); +PIP_EXPORT bool operator <(const PIDateTime & t0, const PIDateTime & t1); +PIP_EXPORT bool operator >(const PIDateTime & t0, const PIDateTime & t1); +inline bool operator !=(const PIDateTime & t0, const PIDateTime & t1) {return !(t0 == t1);} +inline bool operator <=(const PIDateTime & t0, const PIDateTime & t1) {return !(t0 > t1);} +inline bool operator >=(const PIDateTime & t0, const PIDateTime & t1) {return !(t0 < t1);} +inline PIByteArray & operator <<(PIByteArray & s, const PIDateTime & v) {s << v.year << v.month << v.day << v.hours << v.minutes << v.seconds << v.milliseconds; return s;} +inline PIByteArray & operator >>(PIByteArray & s, PIDateTime & v) {s >> v.year >> v.month >> v.day >> v.hours >> v.minutes >> v.seconds >> v.milliseconds; return s;} + +//! \relatesalso PICout +//! \~english \brief Output operator to PICout +//! \~russian \brief Оператор вывода в PICout +PIP_EXPORT PICout operator <<(PICout s, const PIDateTime & v); + + +#endif // PIDATETIME_H diff --git a/libs/main/core/piflags.h b/libs/main/core/piflags.h index 56ea9328..4d1f886e 100644 --- a/libs/main/core/piflags.h +++ b/libs/main/core/piflags.h @@ -1,4 +1,5 @@ /*! \file piflags.h + * \ingroup Core * \~\brief * \~english General flags class * \~russian Универсальные флаги diff --git a/libs/main/core/piincludes.h b/libs/main/core/piincludes.h index b4fdf01d..cefec9b0 100644 --- a/libs/main/core/piincludes.h +++ b/libs/main/core/piincludes.h @@ -1,3 +1,9 @@ +/*! \file piincludes.h + * \ingroup Core + * \~\brief + * \~english Minimal PIP includes + * \~russian Минимально-необходимые инклюды PIP +*/ /* PIP - Platform Independent Primitives Minimal PIP includes diff --git a/libs/main/core/piinit.h b/libs/main/core/piinit.h index 2921e926..a1902ab4 100644 --- a/libs/main/core/piinit.h +++ b/libs/main/core/piinit.h @@ -1,4 +1,5 @@ /*! \file piinit.h + * \ingroup Core * \~\brief * \~english Library initialization * \~russian Инициализация библиотеки diff --git a/libs/main/core/piobject.h b/libs/main/core/piobject.h index d32b27aa..1b194ee1 100644 --- a/libs/main/core/piobject.h +++ b/libs/main/core/piobject.h @@ -1,4 +1,5 @@ /*! \file piobject.h + * \ingroup Core * \~\brief * \~english Base object * \~russian Базовый класс diff --git a/libs/main/core/piobject_macros.h b/libs/main/core/piobject_macros.h index 2f440b72..a046c71d 100644 --- a/libs/main/core/piobject_macros.h +++ b/libs/main/core/piobject_macros.h @@ -1,7 +1,8 @@ /*! \file piobject_macros.h - * \~\brief Base object - * - * This file declare macros for PIObject + * \ingroup Core + * \~\brief + * \~english PIObject macros + * \~russian Макросы PIObject */ /* PIP - Platform Independent Primitives diff --git a/libs/main/core/pipropertystorage.h b/libs/main/core/pipropertystorage.h index ac259b72..0355b6c7 100644 --- a/libs/main/core/pipropertystorage.h +++ b/libs/main/core/pipropertystorage.h @@ -1,4 +1,5 @@ /*! \file pipropertystorage.h + * \ingroup Core * \~\brief * \~english Properties array * \~russian Массив свойств diff --git a/libs/main/core/pistring.h b/libs/main/core/pistring.h index 9a4d1d6d..a37c346f 100644 --- a/libs/main/core/pistring.h +++ b/libs/main/core/pistring.h @@ -1,7 +1,8 @@ /*! \file pistring.h - * \brief String - * - * This file declare string and string list classes + * \ingroup Core + * \brief + * \~english String class + * \~russian Класс строки */ /* PIP - Platform Independent Primitives diff --git a/libs/main/core/pistring_std.h b/libs/main/core/pistring_std.h index de50aaa8..8bf649ab 100644 --- a/libs/main/core/pistring_std.h +++ b/libs/main/core/pistring_std.h @@ -1,7 +1,8 @@ /*! \file pistring_std.h - * \brief STD for PIString - * - * This file declare std operators and string conversions + * \ingroup Core + * \brief + * \~english STD convertions for PIString + * \~russian Преобразования в/из STD для строки */ /* PIP - Platform Independent Primitives diff --git a/libs/main/core/pistringlist.h b/libs/main/core/pistringlist.h index 709c7d8f..13f31cee 100644 --- a/libs/main/core/pistringlist.h +++ b/libs/main/core/pistringlist.h @@ -1,4 +1,5 @@ /*! \file pistringlist.h + * \ingroup Core * \~\brief * \~english Based on \a PIDeque strings list * \~russian Основанный на \a PIDeque массив строк diff --git a/libs/main/core/pisystemtime.cpp b/libs/main/core/pisystemtime.cpp new file mode 100644 index 00000000..64e7454a --- /dev/null +++ b/libs/main/core/pisystemtime.cpp @@ -0,0 +1,231 @@ +/* + PIP - Platform Independent Primitives + Unix time + Ivan Pelipenko peri4ko@yandex.ru + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + +#include "piincludes_p.h" +#include "pisystemtime.h" +#include "pitime.h" +#include +#ifdef QNX +# include +#endif +#ifndef MICRO_PIP +# include "pisystemtests.h" +#elif defined(ARDUINO) +# include +#endif +#ifdef WINDOWS + extern FILETIME __pi_ftjan1970; + long long __PIQueryPerformanceCounter() {LARGE_INTEGER li; QueryPerformanceCounter(&li); return li.QuadPart;} +#endif +#ifdef MAC_OS +//# include +//# include +# include +//# include + extern clock_serv_t __pi_mac_clock; +#endif +#ifdef MICRO_PIP +# include +#endif + + +//! \addtogroup Core +//! \{ +//! \class PISystemTime pisystemtime.h +//! \brief +//! \~english System time with nanosecond precision +//! \~russian Системное время с точностью до наносекунд +//! +//! \~english \section PISystemTime_sec0 Synopsis +//! \~russian \section PISystemTime_sec0 Краткий обзор +//! \~english +//! This class provide arithmetic functions for POSIX system time. +//! This time represents as seconds and nanosecons in integer formats. +//! You can take current system time with function \a PISystemTime::current(), +//! compare times, sum or subtract two times, convert time to/from +//! seconds, milliseconds, microseconds or nanoseconds. +//! +//! \~russian +//! Этот класс предоставляет арифметику для системного времени в формате POSIX. +//! Это время представлено в виде целочисленных секунд и наносекунд. +//! Можно взять текущее время с помощью метода \a PISystemTime::current(), +//! сравнивать, суммировать и вычитать времена, преобразовывать в/из +//! секунд, миллисекунд, микросекунд и наносекунд. +//! +//! \~english \section PISystemTime_sec1 Example +//! \~russian \section PISystemTime_sec1 Пример +//! \~\snippet pitimer.cpp system_time +//! +//! \} + + +//! \addtogroup Core +//! \{ +//! \class PITimeMeasurer pisystemtime.h +//! \brief +//! \~english Time measurements +//! \~russian Измерение времени +//! +//! \~english \section PITimeMeasurer_sec0 Usage +//! \~russian \section PITimeMeasurer_sec0 Использование +//! \~english +//! Function \a reset() set time mark to current +//! system time, then functions "double elapsed_*()" returns time elapsed from this mark. +//! These functions can returns nano-, micro-, milli- and seconds with suffixes "n", "u", "m" +//! and "s" +//! +//! \~russian +//! Метод \a reset() устанавливает текущую метку системного времени. Далее методы +//! "double elapsed_*()" возвращают время, прошедшее от установленной метки. +//! Эти методы возвращают нано, микро, милли и секунды с приставками +//! "n", "u", "m" и "s". +//! +//! \} + + + + +//! \details +//! \warning +//! \~english +//! Use this function to sleep for difference of system times or constructs system time. +//! If you call this function on system time returned with \a PISystemTime::current() thread will be sleep almost forever +//! \~russian +//! Используйте этот метод для ожидания разниц системных времен или своего времени. +//! Если метод будет вызван для системного времени \a PISystemTime::current(), то +//! ожидание будет почти бесконечным +void PISystemTime::sleep() { + piUSleep(piFloord(toMicroseconds())); +} + + +void PISystemTime::toTimespec(void * ts) { +#ifndef WINDOWS + ((timespec*)ts)->tv_sec = seconds; + ((timespec*)ts)->tv_nsec = nanoseconds; +#endif +} + + +PISystemTime PISystemTime::abs() const { + if (seconds < 0) + return PISystemTime(piAbsl(seconds) - 1, 1000000000l - piAbsl(nanoseconds)); + else + return PISystemTime(piAbsl(seconds), piAbsl(nanoseconds)); +} + + +PISystemTime PISystemTime::current(bool precise_but_not_system) { +#ifdef WINDOWS + if (precise_but_not_system) { + llong qpc(0); + if (__pi_perf_freq > 0) { + qpc = __PIQueryPerformanceCounter(); + return PISystemTime::fromSeconds(qpc / double(__pi_perf_freq)); + } + return PISystemTime(); + } else { + FILETIME ft, sft; +# if (_WIN32_WINNT >= 0x0602) + GetSystemTimePreciseAsFileTime(&ft); +# else + GetSystemTimeAsFileTime(&ft); +# endif + sft.dwHighDateTime = ft.dwHighDateTime - __pi_ftjan1970.dwHighDateTime; + if (ft.dwLowDateTime < __pi_ftjan1970.dwLowDateTime) { + sft.dwLowDateTime = ft.dwLowDateTime + (0xFFFFFFFF - __pi_ftjan1970.dwLowDateTime); + sft.dwHighDateTime--; + } else + sft.dwLowDateTime = ft.dwLowDateTime - __pi_ftjan1970.dwLowDateTime; + ullong lt = ullong(sft.dwHighDateTime) * 0x100000000U + ullong(sft.dwLowDateTime); + return PISystemTime(lt / 10000000U, (lt % 10000000U) * 100U); + } +#elif defined(MAC_OS) + mach_timespec_t t_cur; + clock_get_time(__pi_mac_clock, &t_cur); +#elif defined(MICRO_PIP) + timespec t_cur; +# ifdef ARDUINO + static const uint32_t offSetSinceEpoch_s = 1581897605UL; + uint32_t mt = millis(); + t_cur.tv_sec = offSetSinceEpoch_s + (mt / 1000); + t_cur.tv_nsec = (mt - (mt / 1000)) * 1000000UL; +# else + timeval tv; + tv.tv_sec = 0; + tv.tv_usec = 0; + gettimeofday(&tv, NULL); + t_cur.tv_sec = tv.tv_sec; + t_cur.tv_nsec = tv.tv_usec * 1000; +# endif +#else + timespec t_cur; + clock_gettime(precise_but_not_system ? CLOCK_MONOTONIC : 0, &t_cur); +#endif +#ifndef WINDOWS + return PISystemTime(t_cur.tv_sec, t_cur.tv_nsec); +#endif +} + + + +PITimeMeasurer::PITimeMeasurer() { + reset(); +} + + +double PITimeMeasurer::elapsed_n() const { + return (PISystemTime::current(true) - t_st).toNanoseconds() +#ifndef MICRO_PIP + - PISystemTests::time_elapsed_ns +#endif + ; +} + + +double PITimeMeasurer::elapsed_u() const { + return (PISystemTime::current(true) - t_st).toMicroseconds() +#ifndef MICRO_PIP + - PISystemTests::time_elapsed_ns / 1.E+3 +#endif + ; +} + + +double PITimeMeasurer::elapsed_m() const { + return (PISystemTime::current(true) - t_st).toMilliseconds() +#ifndef MICRO_PIP + - PISystemTests::time_elapsed_ns / 1.E+6 +#endif + ; +} + + +double PITimeMeasurer::elapsed_s() const { + return (PISystemTime::current(true) - t_st).toSeconds() +#ifndef MICRO_PIP + - PISystemTests::time_elapsed_ns / 1.E+9 +#endif + ; +} + + +PISystemTime PITimeMeasurer::elapsed() const { + return (PISystemTime::current(true) - t_st); +} diff --git a/libs/main/core/pisystemtime.h b/libs/main/core/pisystemtime.h new file mode 100644 index 00000000..42854549 --- /dev/null +++ b/libs/main/core/pisystemtime.h @@ -0,0 +1,245 @@ +/*! \file pisystemtime.h + * \ingroup Core + * \~\brief + * \~english System time structs and methods + * \~russian Типы и методы системного времени +*/ +/* + PIP - Platform Independent Primitives + Time structs + Ivan Pelipenko peri4ko@yandex.ru + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + +#ifndef PISYSTEMTIME_H +#define PISYSTEMTIME_H + + +#include "pistring.h" + + +class PIP_EXPORT PISystemTime { +public: + + //! \~english Contructs time with seconds and nanoseconds = 0 + //! \~russian Создает время с секундами и наносекундами = 0 + PISystemTime() {seconds = nanoseconds = 0;} + + //! \~english Contructs time with "s" seconds and "ns" nanoseconds + //! \~russian Создает время с секундами "s" и наносекундами "ns" + PISystemTime(int s, int ns) {seconds = s; nanoseconds = ns; checkOverflows();} + + + //! \~english Returns time value in seconds + //! \~russian Возвращает значение времени в секундах + double toSeconds() const {return double(seconds) + nanoseconds / 1.e+9;} + + //! \~english Returns time value in milliseconds + //! \~russian Возвращает значение времени в миллисекундах + double toMilliseconds() const {return seconds * 1.e+3 + nanoseconds / 1.e+6;} + + //! \~english Returns time value in microseconds + //! \~russian Возвращает значение времени в микросекундах + double toMicroseconds() const {return seconds * 1.e+6 + nanoseconds / 1.e+3;} + + //! \~english Returns time value in nanoseconds + //! \~russian Возвращает значение времени в наносекундах + double toNanoseconds() const {return seconds * 1.e+9 + double(nanoseconds);} + + + //! \~english Add to time "v" seconds + //! \~russian Добавляет ко времени "v" секунд + PISystemTime & addSeconds(double v) {*this += fromSeconds(v); return *this;} + + //! \~english Add to time "v" milliseconds + //! \~russian Добавляет ко времени "v" миллисекунд + PISystemTime & addMilliseconds(double v) {*this += fromMilliseconds(v); return *this;} + + //! \~english Add to time "v" microseconds + //! \~russian Добавляет ко времени "v" микросекунд + PISystemTime & addMicroseconds(double v) {*this += fromMicroseconds(v); return *this;} + + //! \~english Add to time "v" nanoseconds + //! \~russian Добавляет ко времени "v" наносекунд + PISystemTime & addNanoseconds(double v) {*this += fromNanoseconds(v); return *this;} + + + //! \~english Sleep for this time + //! \~russian Ожидать это время + void sleep(); + + //! \~english On *nix system assign current value to timespec struct + //! \~russian На *nix системах присваивает время к timespec структуре + void toTimespec(void * ts); + + //! \~english Returns copy of this time with absolutely values of s and ns + //! \~russian Возвращает копию времени с модулем значения + PISystemTime abs() const; + + //! \~english Returns sum of this time with "t" + //! \~russian Возвращает сумму этого времени с "t" + PISystemTime operator +(const PISystemTime & t) const {PISystemTime tt(*this); tt.seconds += t.seconds; tt.nanoseconds += t.nanoseconds; tt.checkOverflows(); return tt;} + + //! \~english Returns difference between this time and "t" + //! \~russian Возвращает разницу между этим временем и "t" + PISystemTime operator -(const PISystemTime & t) const {PISystemTime tt(*this); tt.seconds -= t.seconds; tt.nanoseconds -= t.nanoseconds; tt.checkOverflows(); return tt;} + + //! \~english Returns multiplication between this time and "t" + //! \~russian Возвращает это временя умноженное на "t" + PISystemTime operator *(const double & v) const {return fromMilliseconds(toMilliseconds() * v);} + + //! \~english Returns division between this time and "t" + //! \~russian Возвращает это временя поделённое на "t" + PISystemTime operator /(const double & v) const {return fromMilliseconds(toMilliseconds() / v);} + + //! \~english Add to time "t" + //! \~russian Добавляет ко времени "t" + PISystemTime & operator +=(const PISystemTime & t) {seconds += t.seconds; nanoseconds += t.nanoseconds; checkOverflows(); return *this;} + + //! \~english Subtract from time "t" + //! \~russian Вычитает из времени "t" + PISystemTime & operator -=(const PISystemTime & t) {seconds -= t.seconds; nanoseconds -= t.nanoseconds; checkOverflows(); return *this;} + + //! \~english Multiply time by "v" + //! \~russian Умножает время на "v" + PISystemTime & operator *=(const double & v) {*this = fromMilliseconds(toMilliseconds() * v); return *this;} + + //! \~english Divide time by "v" + //! \~russian Делит время на "v" + PISystemTime & operator /=(const double & v) {*this = fromMilliseconds(toMilliseconds() / v); return *this;} + + + //! \~english Compare operator + //! \~russian Оператор сравнения + bool operator ==(const PISystemTime & t) const {return ((seconds == t.seconds) && (nanoseconds == t.nanoseconds));} + + //! \~english Compare operator + //! \~russian Оператор сравнения + bool operator !=(const PISystemTime & t) const {return ((seconds != t.seconds) || (nanoseconds != t.nanoseconds));} + + //! \~english Compare operator + //! \~russian Оператор сравнения + bool operator >(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds > t.nanoseconds; return seconds > t.seconds;} + + //! \~english Compare operator + //! \~russian Оператор сравнения + bool operator <(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds < t.nanoseconds; return seconds < t.seconds;} + + //! \~english Compare operator + //! \~russian Оператор сравнения + bool operator >=(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds >= t.nanoseconds; return seconds >= t.seconds;} + + //! \~english Compare operator + //! \~russian Оператор сравнения + bool operator <=(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds <= t.nanoseconds; return seconds <= t.seconds;} + + + //! \~english Contructs time from seconds "v" + //! \~russian Создает время из "v" секунд + static PISystemTime fromSeconds(double v) {int s = piFloord(v); return PISystemTime(s, int((v - s) * 1000000000.));} + + //! \~english Contructs time from milliseconds "v" + //! \~russian Создает время из "v" миллисекунд + static PISystemTime fromMilliseconds(double v) {int s = piFloord(v / 1000.); return PISystemTime(s, int((v / 1000. - s) * 1000000000.));} + + //! \~english Contructs time from microseconds "v" + //! \~russian Создает время из "v" микросекунд + static PISystemTime fromMicroseconds(double v) {int s = piFloord(v / 1000000.); return PISystemTime(s, int((v / 1000000. - s) * 1000000000.));} + + //! \~english Contructs time from nanoseconds "v" + //! \~russian Создает время из "v" наносекунд + static PISystemTime fromNanoseconds(double v) {int s = piFloord(v / 1000000000.); return PISystemTime(s, int((v / 1000000000. - s) * 1000000000.));} + + //! \~english Returns current system time + //! \~russian Возвращает текущее системное время + static PISystemTime current(bool precise_but_not_system = false); + + //! \~english Seconds time part + //! \~russian Секунды времени + int seconds; + + //! \~english Nanoseconds time part + //! \~russian Наносекунды времени + int nanoseconds; + +private: + void checkOverflows() {while (nanoseconds >= 1000000000) {nanoseconds -= 1000000000; seconds++;} while (nanoseconds < 0) {nanoseconds += 1000000000; seconds--;}} + +}; + +//! \relatesalso PICout +//! \~english \brief Output operator to PICout +//! \~russian \brief Оператор вывода в PICout +inline PICout operator <<(PICout s, const PISystemTime & v) {s.space(); s.setControl(0, true); s << "(" << v.seconds << " s, " << v.nanoseconds << " ns)"; s.restoreControl(); return s;} + + + + +class PIP_EXPORT PITimeMeasurer { +public: + PITimeMeasurer(); + + /** \brief Set internal time mark to current system time + * \details This function used for set start time mark. Later + * you can find out elapsed time from this time mark to any + * moment of time with \a elapsed_s(), \a elapsed_m(), + * \a elapsed_u() or \a elapsed_n() functions. + * \sa \a elapsed_s(), \a elapsed_m(), \a elapsed_u(), \a elapsed_n() */ + void reset() {t_st = PISystemTime::current(true);} + + //! \brief Returns nanoseconds elapsed from last \a reset() execution or from timer measurer creation. + double elapsed_n() const; + + //! \brief Returns microseconds elapsed from last \a reset() execution or from timer measurer creation. + double elapsed_u() const; + + //! \brief Returns milliseconds elapsed from last \a reset() execution or from timer measurer creation. + double elapsed_m() const; + + //! \brief Returns seconds elapsed from last \a reset() execution or from timer measurer creation. + double elapsed_s() const; + + //! \brief Returns PISystemTime elapsed from last \a reset() execution or from timer measurer creation. + PISystemTime elapsed() const; + + double reset_time_n() const {return t_st.toNanoseconds();} + double reset_time_u() const {return t_st.toMicroseconds();} + double reset_time_m() const {return t_st.toMilliseconds();} + double reset_time_s() const {return t_st.toSeconds();} + + //! \brief Returns time mark of last \a reset() execution or timer measurer creation. + PISystemTime reset_time() {return t_st;} + + //! \brief Returns nanoseconds representation of current system time. + static double elapsed_system_n() {return PISystemTime::current(true).toNanoseconds();} + + //! \brief Returns microseconds representation of current system time. + static double elapsed_system_u() {return PISystemTime::current(true).toMicroseconds();} + + //! \brief Returns milliseconds representation of current system time. + static double elapsed_system_m() {return PISystemTime::current(true).toMilliseconds();} + + //! \brief Returns seconds representation of current system time. + static double elapsed_system_s() {return PISystemTime::current(true).toSeconds();} + + //! \brief Returns time mark of current system time. + static PISystemTime elapsed_system() {return PISystemTime::current(true);} + +private: + PISystemTime t_st, t_cur; + +}; + +#endif // PITIME_H diff --git a/libs/main/core/pitime.cpp b/libs/main/core/pitime.cpp index 8bc1c578..7a2f347c 100644 --- a/libs/main/core/pitime.cpp +++ b/libs/main/core/pitime.cpp @@ -1,6 +1,5 @@ /* PIP - Platform Independent Primitives - Timer Ivan Pelipenko peri4ko@yandex.ru This program is free software: you can redistribute it and/or modify @@ -19,79 +18,18 @@ #include "piincludes_p.h" #include "pitime.h" +#ifdef QNX +# include +#endif #ifndef MICRO_PIP # include "pisystemtests.h" #elif defined(ARDUINO) # include #endif -#ifdef WINDOWS - extern FILETIME __pi_ftjan1970; - long long __PIQueryPerformanceCounter() {LARGE_INTEGER li; QueryPerformanceCounter(&li); return li.QuadPart;} -#endif -#ifdef MAC_OS -//# include -//# include -# include -//# include - extern clock_serv_t __pi_mac_clock; -#endif #ifdef MICRO_PIP # include #endif -//! \addtogroup Core -//! \{ -//! \class PISystemTime pitime.h -//! \brief -//! \~english System time with nanosecond precision -//! \~russian Системное время с точностью до наносекунд -//! -//! \~english \section PISystemTime_sec0 Synopsis -//! \~russian \section PISystemTime_sec0 Краткий обзор -//! \~english -//! This class provide arithmetic functions for POSIX system time. -//! This time represents as seconds and nanosecons in integer formats. -//! You can take current system time with function \a PISystemTime::current(), -//! compare times, sum or subtract two times, convert time to/from -//! seconds, milliseconds, microseconds or nanoseconds. -//! -//! \~russian -//! Этот класс предоставляет арифметику для системного времени в формате POSIX. -//! Это время представлено в виде целочисленных секунд и наносекунд. -//! Можно взять текущее время с помощью метода \a PISystemTime::current(), -//! сравнивать, суммировать и вычитать времена, преобразовывать в/из -//! секунд, миллисекунд, микросекунд и наносекунд. -//! -//! \~english \section PISystemTime_sec1 Example -//! \~russian \section PISystemTime_sec1 Пример -//! \~\snippet pitimer.cpp system_time -//! -//! \} - - -//! \addtogroup Core -//! \{ -//! \class PITimeMeasurer pitime.h -//! \brief -//! \~english Time measurements -//! \~russian Измерение времени -//! -//! \~english \section PITimeMeasurer_sec0 Usage -//! \~russian \section PITimeMeasurer_sec0 Использование -//! \~english -//! Function \a reset() set time mark to current -//! system time, then functions "double elapsed_*()" returns time elapsed from this mark. -//! These functions can returns nano-, micro-, milli- and seconds with suffixes "n", "u", "m" -//! and "s" -//! -//! \~russian -//! Метод \a reset() устанавливает текущую метку системного времени. Далее методы -//! "double elapsed_*()" возвращают время, прошедшее от установленной метки. -//! Эти методы возвращают нано, микро, милли и секунды с приставками -//! "n", "u", "m" и "s". -//! -//! \} - //! \details //! \~english @@ -121,431 +59,3 @@ void piUSleep(int usecs) { # endif #endif } - - -bool operator ==(const PITime & t0, const PITime & t1) { - return (t0.hours == t1.hours && t0.minutes == t1.minutes && t0.seconds == t1.seconds); -} - - -bool operator <(const PITime & t0, const PITime & t1) { - if (t0.hours == t1.hours) { - if (t0.minutes == t1.minutes) { - return t0.seconds < t1.seconds; - } else return t0.minutes < t1.minutes; - } else return t0.hours < t1.hours; -} - - -bool operator >(const PITime & t0, const PITime & t1) { - if (t0.hours == t1.hours) { - if (t0.minutes == t1.minutes) { - return t0.seconds > t1.seconds; - } else return t0.minutes > t1.minutes; - } else return t0.hours > t1.hours; -} - -bool operator ==(const PIDate & t0, const PIDate & t1) { - return (t0.year == t1.year && t0.month == t1.month && t0.day == t1.day); -} - - -bool operator <(const PIDate & t0, const PIDate & t1) { - if (t0.year == t1.year) { - if (t0.month == t1.month) { - return t0.day < t1.day; - } else return t0.month < t1.month; - } else return t0.year < t1.year; -} - - -bool operator >(const PIDate & t0, const PIDate & t1) { - if (t0.year == t1.year) { - if (t0.month == t1.month) { - return t0.day > t1.day; - } else return t0.month > t1.month; - } else return t0.year > t1.year; -} - -bool operator ==(const PIDateTime & t0, const PIDateTime & t1) { - return (t0.year == t1.year && t0.month == t1.month && t0.day == t1.day && - t0.hours == t1.hours && t0.minutes == t1.minutes && t0.seconds == t1.seconds); -} - - -bool operator <(const PIDateTime & t0, const PIDateTime & t1) { - if (t0.year == t1.year) { - if (t0.month == t1.month) { - if (t0.day == t1.day) { - if (t0.hours == t1.hours) { - if (t0.minutes == t1.minutes) { - return t0.seconds < t1.seconds; - } else return t0.minutes < t1.minutes; - } else return t0.hours < t1.hours; - } else return t0.day < t1.day; - } else return t0.month < t1.month; - } else return t0.year < t1.year; -} - - -bool operator >(const PIDateTime & t0, const PIDateTime & t1) { - if (t0.year == t1.year) { - if (t0.month == t1.month) { - if (t0.day == t1.day) { - if (t0.hours == t1.hours) { - if (t0.minutes == t1.minutes) { - return t0.seconds > t1.seconds; - } else return t0.minutes > t1.minutes; - } else return t0.hours > t1.hours; - } else return t0.day > t1.day; - } else return t0.month > t1.month; - } else return t0.year > t1.year; -} - - -PISystemTime PITime::toSystemTime() const { - return PISystemTime((hours * 60. + minutes) * 60. + seconds, milliseconds * 1000.); -} - - -PITime PITime::current() { - time_t rt = ::time(0); - tm * pt = localtime(&rt); - PITime t; - t.seconds = pt->tm_sec; - t.minutes = pt->tm_min; - t.hours = pt->tm_hour; - return t; -} - - -PITime PITime::fromSystemTime(const PISystemTime & st) { - double s = st.toSeconds(); - int v = s; - PITime ret; - ret.milliseconds = (s - v) * 1000; - ret.seconds = v % 60; v = (v - ret.seconds) / 60; - ret.minutes = v % 60; v = (v - ret.minutes) / 60; - ret.hours = v; - return ret; -} - - -PIDate PIDate::current() { - time_t rt = ::time(0); - tm * pt = localtime(&rt); - PIDate d; - d.day = pt->tm_mday; - d.month = pt->tm_mon + 1; - d.year = pt->tm_year + 1900; - return d; -} - - -PIDateTime PIDateTime::current() { - time_t rt = ::time(0); - tm * pt = localtime(&rt); - PIDateTime dt; - dt.milliseconds = 0; - dt.seconds = pt->tm_sec; - dt.minutes = pt->tm_min; - dt.hours = pt->tm_hour; - dt.day = pt->tm_mday; - dt.month = pt->tm_mon + 1; - dt.year = pt->tm_year + 1900; - return dt; -} - - -//! \details -//! \warning -//! \~english -//! Use this function to sleep for difference of system times or constructs system time. -//! If you call this function on system time returned with \a PISystemTime::current() thread will be sleep almost forever -//! \~russian -//! Используйте этот метод для ожидания разниц системных времен или своего времени. -//! Если метод будет вызван для системного времени \a PISystemTime::current(), то -//! ожидание будет почти бесконечным -void PISystemTime::sleep() { - piUSleep(piFloord(toMicroseconds())); -} - - -void PISystemTime::toTimespec(void * ts) { -#ifndef WINDOWS - ((timespec*)ts)->tv_sec = seconds; - ((timespec*)ts)->tv_nsec = nanoseconds; -#endif -} - -PISystemTime PISystemTime::abs() const { - if (seconds < 0) - return PISystemTime(piAbsl(seconds) - 1, 1000000000l - piAbsl(nanoseconds)); - else - return PISystemTime(piAbsl(seconds), piAbsl(nanoseconds)); -} - - -PISystemTime PISystemTime::current(bool precise_but_not_system) { -#ifdef WINDOWS - if (precise_but_not_system) { - llong qpc(0); - if (__pi_perf_freq > 0) { - qpc = __PIQueryPerformanceCounter(); - return PISystemTime::fromSeconds(qpc / double(__pi_perf_freq)); - } - return PISystemTime(); - } else { - FILETIME ft, sft; -# if (_WIN32_WINNT >= 0x0602) - GetSystemTimePreciseAsFileTime(&ft); -# else - GetSystemTimeAsFileTime(&ft); -# endif - sft.dwHighDateTime = ft.dwHighDateTime - __pi_ftjan1970.dwHighDateTime; - if (ft.dwLowDateTime < __pi_ftjan1970.dwLowDateTime) { - sft.dwLowDateTime = ft.dwLowDateTime + (0xFFFFFFFF - __pi_ftjan1970.dwLowDateTime); - sft.dwHighDateTime--; - } else - sft.dwLowDateTime = ft.dwLowDateTime - __pi_ftjan1970.dwLowDateTime; - ullong lt = ullong(sft.dwHighDateTime) * 0x100000000U + ullong(sft.dwLowDateTime); - return PISystemTime(lt / 10000000U, (lt % 10000000U) * 100U); - } -#elif defined(MAC_OS) - mach_timespec_t t_cur; - clock_get_time(__pi_mac_clock, &t_cur); -#elif defined(MICRO_PIP) - timespec t_cur; -# ifdef ARDUINO - static const uint32_t offSetSinceEpoch_s = 1581897605UL; - uint32_t mt = millis(); - t_cur.tv_sec = offSetSinceEpoch_s + (mt / 1000); - t_cur.tv_nsec = (mt - (mt / 1000)) * 1000000UL; -# else - timeval tv; - tv.tv_sec = 0; - tv.tv_usec = 0; - gettimeofday(&tv, NULL); - t_cur.tv_sec = tv.tv_sec; - t_cur.tv_nsec = tv.tv_usec * 1000; -# endif -#else - timespec t_cur; - clock_gettime(precise_but_not_system ? CLOCK_MONOTONIC : 0, &t_cur); -#endif -#ifndef WINDOWS - return PISystemTime(t_cur.tv_sec, t_cur.tv_nsec); -#endif -} - - -PIString PITime::toString(const PIString & format) const { - PIString ts = format; - ts.replace("hh", PIString::fromNumber(hours).expandLeftTo(2, '0')); - ts.replace("h", PIString::fromNumber(hours)); - ts.replace("mm", PIString::fromNumber(minutes).expandLeftTo(2, '0')); - ts.replace("m", PIString::fromNumber(minutes)); - ts.replace("ss", PIString::fromNumber(seconds).expandLeftTo(2, '0')); - ts.replace("s", PIString::fromNumber(seconds)); - ts.replace("zzz", PIString::fromNumber(milliseconds).expandLeftTo(3, '0')); - ts.replace("zz", PIString::fromNumber(milliseconds).expandLeftTo(2, '0')); - ts.replace("z", PIString::fromNumber(milliseconds)); - return ts; -} - - -PIString PIDate::toString(const PIString & format) const { - PIString ts = format; - ts.replace("yyyy", PIString::fromNumber(year).expandLeftTo(4, '0')); - ts.replace("yy", PIString::fromNumber(year).right(2)); - ts.replace("y", PIString::fromNumber(year).right(1)); - ts.replace("MM", PIString::fromNumber(month).expandLeftTo(2, '0')); - ts.replace("M", PIString::fromNumber(month)); - ts.replace("dd", PIString::fromNumber(day).expandLeftTo(2, '0')); - ts.replace("d", PIString::fromNumber(day)); - return ts; -} - - -PIString PIDateTime::toString(const PIString & format) const { - PIString ts = format; - ts.replace("yyyy", PIString::fromNumber(year).expandLeftTo(4, '0')); - ts.replace("yy", PIString::fromNumber(year).right(2)); - ts.replace("y", PIString::fromNumber(year).right(1)); - ts.replace("MM", PIString::fromNumber(month).expandLeftTo(2, '0')); - ts.replace("M", PIString::fromNumber(month)); - ts.replace("dd", PIString::fromNumber(day).expandLeftTo(2, '0')); - ts.replace("d", PIString::fromNumber(day)); - ts.replace("hh", PIString::fromNumber(hours).expandLeftTo(2, '0')); - ts.replace("h", PIString::fromNumber(hours)); - ts.replace("mm", PIString::fromNumber(minutes).expandLeftTo(2, '0')); - ts.replace("m", PIString::fromNumber(minutes)); - ts.replace("ss", PIString::fromNumber(seconds).expandLeftTo(2, '0')); - ts.replace("s", PIString::fromNumber(seconds)); - ts.replace("zzz", PIString::fromNumber(milliseconds).expandLeftTo(3, '0')); - ts.replace("zz", PIString::fromNumber(milliseconds).expandLeftTo(2, '0')); - ts.replace("z", PIString::fromNumber(milliseconds)); - return ts; -} - - -time_t PIDateTime::toSecondSinceEpoch() const { - tm pt; - memset(&pt, 0, sizeof(pt)); - pt.tm_sec = seconds; - pt.tm_min = minutes; - pt.tm_hour = hours; - pt.tm_mday = day; - pt.tm_mon = month - 1; -#ifdef WINDOWS - pt.tm_year = piMaxi(year - 1900, 70); -#else - pt.tm_year = piMaxi(year - 1900, 0); -#endif - return mktime(&pt); -} - - -PIDateTime PIDateTime::fromSecondSinceEpoch(const time_t sec) { - tm * pt = localtime(&sec); - PIDateTime dt; - dt.seconds = pt->tm_sec; - dt.minutes = pt->tm_min; - dt.hours = pt->tm_hour; - dt.day = pt->tm_mday; - dt.month = pt->tm_mon + 1; - dt.year = pt->tm_year + 1900; - return dt; - -} - - -PIString time2string(const PITime & time, const PIString & format) { - PIString ts = format; - ts.replace("hh", PIString::fromNumber(time.hours).expandLeftTo(2, '0')); - ts.replace("h", PIString::fromNumber(time.hours)); - ts.replace("mm", PIString::fromNumber(time.minutes).expandLeftTo(2, '0')); - ts.replace("m", PIString::fromNumber(time.minutes)); - ts.replace("ss", PIString::fromNumber(time.seconds).expandLeftTo(2, '0')); - ts.replace("s", PIString::fromNumber(time.seconds)); - return ts; -} - - -PIString date2string(const PIDate & date, const PIString & format) { - PIString ts = format; - ts.replace("yyyy", PIString::fromNumber(date.year).expandLeftTo(4, '0')); - ts.replace("yy", PIString::fromNumber(date.year).right(2)); - ts.replace("y", PIString::fromNumber(date.year).right(1)); - ts.replace("MM", PIString::fromNumber(date.month).expandLeftTo(2, '0')); - ts.replace("M", PIString::fromNumber(date.month)); - ts.replace("dd", PIString::fromNumber(date.day).expandLeftTo(2, '0')); - ts.replace("d", PIString::fromNumber(date.day)); - return ts; -} - - -PIString datetime2string(const PIDateTime & date, const PIString & format) { - PIString ts = format; - ts.replace("hh", PIString::fromNumber(date.hours).expandLeftTo(2, '0')); - ts.replace("h", PIString::fromNumber(date.hours)); - ts.replace("mm", PIString::fromNumber(date.minutes).expandLeftTo(2, '0')); - ts.replace("m", PIString::fromNumber(date.minutes)); - ts.replace("ss", PIString::fromNumber(date.seconds).expandLeftTo(2, '0')); - ts.replace("s", PIString::fromNumber(date.seconds)); - ts.replace("yyyy", PIString::fromNumber(date.year).expandLeftTo(4, '0')); - ts.replace("yy", PIString::fromNumber(date.year).right(2)); - ts.replace("y", PIString::fromNumber(date.year).right(1)); - ts.replace("MM", PIString::fromNumber(date.month).expandLeftTo(2, '0')); - ts.replace("M", PIString::fromNumber(date.month)); - ts.replace("dd", PIString::fromNumber(date.day).expandLeftTo(2, '0')); - ts.replace("d", PIString::fromNumber(date.day)); - return ts; -} - - - -PITimeMeasurer::PITimeMeasurer() { - reset(); -} - - -double PITimeMeasurer::elapsed_n() const { - return (PISystemTime::current(true) - t_st).toNanoseconds() -#ifndef MICRO_PIP - - PISystemTests::time_elapsed_ns -#endif - ; -} - - -double PITimeMeasurer::elapsed_u() const { - return (PISystemTime::current(true) - t_st).toMicroseconds() -#ifndef MICRO_PIP - - PISystemTests::time_elapsed_ns / 1.E+3 -#endif - ; -} - - -double PITimeMeasurer::elapsed_m() const { - return (PISystemTime::current(true) - t_st).toMilliseconds() -#ifndef MICRO_PIP - - PISystemTests::time_elapsed_ns / 1.E+6 -#endif - ; -} - - -double PITimeMeasurer::elapsed_s() const { - return (PISystemTime::current(true) - t_st).toSeconds() -#ifndef MICRO_PIP - - PISystemTests::time_elapsed_ns / 1.E+9 -#endif - ; -} - - -PISystemTime PITimeMeasurer::elapsed() const { - return (PISystemTime::current(true) - t_st); -} - - -PICout operator <<(PICout s, const PITime & v) { - s.space(); - s.setControl(0, true); - s << "PITime(" << v.hours << ":"; - s << PIString::fromNumber(v.minutes).expandLeftTo(2, '0') << ":"; - s << PIString::fromNumber(v.seconds).expandLeftTo(2, '0') << ":"; - s << PIString::fromNumber(v.milliseconds).expandLeftTo(3, '0') << ")"; - s.restoreControl(); - return s; -} - - -PICout operator <<(PICout s, const PIDate & v) { - s.space(); - s.setControl(0, true); - s << "PIDate(" << v.day << "-"; - s << PIString::fromNumber(v.month).expandLeftTo(2, '0') << "-"; - s << v.year << ")"; - s.restoreControl(); - return s; -} - - -PICout operator <<(PICout s, const PIDateTime & v) { - s.space(); - s.setControl(0, true); - s << "PIDateTime("; - s << v.day << "-"; - s << PIString::fromNumber(v.month).expandLeftTo(2, '0') << "-"; - s << v.year << " "; - s << v.hours << ":"; - s << PIString::fromNumber(v.minutes).expandLeftTo(2, '0') << ":"; - s << PIString::fromNumber(v.seconds).expandLeftTo(2, '0') << ":"; - s << PIString::fromNumber(v.milliseconds).expandLeftTo(3, '0') << ")"; - s.restoreControl(); - return s; -} - diff --git a/libs/main/core/pitime.h b/libs/main/core/pitime.h index 3ee5c34e..29c36005 100644 --- a/libs/main/core/pitime.h +++ b/libs/main/core/pitime.h @@ -1,12 +1,11 @@ /*! \file pitime.h * \ingroup Core * \~\brief - * \~english Time structs and methods - * \~russian Типы и методы времени + * \~english System time, time and date + * \~russian Системное время, время и дата */ /* PIP - Platform Independent Primitives - Time structs Ivan Pelipenko peri4ko@yandex.ru This program is free software: you can redistribute it and/or modify @@ -26,348 +25,34 @@ #ifndef PITIME_H #define PITIME_H +#include "pidatetime.h" -#include "pistring.h" -#include -#ifdef QNX -# include -#endif - +//! \ingroup Core //! \~english Precise sleep for "usecs" microseconds //! \~russian Точно ожидает "usecs" микросекунд PIP_EXPORT void piUSleep(int usecs); // on !Windows consider constant "usleep" offset -//! ~\brief +//! \ingroup Core +//! \brief //! \~english Precise sleep for "msecs" milliseconds //! \~russian Точно ожидает "msecs" миллисекунд -//! ~\details +//! \~\details //! \~english This function exec \a piUSleep (msecs * 1000) //! \~russian Этот метод вызывает \a piUSleep (msecs * 1000) inline void piMSleep(double msecs) {piUSleep(int(msecs * 1000.));} // on !Windows consider constant "usleep" offset -//! ~\brief +//! \ingroup Core +//! \brief //! \~english Precise sleep for "secs" seconds //! \~russian Точно ожидает "secs" секунд -//! ~\details +//! \~\details //! \~english This function exec \a piUSleep (msecs * 1000000) //! \~russian Этот метод вызывает \a piUSleep (msecs * 1000000) inline void piSleep(double secs) {piUSleep(int(secs * 1000000.));} // on !Windows consider constant "usleep" offset +//! \ingroup Core //! \~english Shortest available on current system sleep //! \~russian Наименее возможное для данной системы по длительности ожидание inline void piMinSleep() {piMSleep(PIP_MIN_MSLEEP);} - - -class PIP_EXPORT PISystemTime { -public: - - //! \~english Contructs time with seconds and nanoseconds = 0 - //! \~russian Создает время с секундами и наносекундами = 0 - PISystemTime() {seconds = nanoseconds = 0;} - - //! \~english Contructs time with "s" seconds and "ns" nanoseconds - //! \~russian Создает время с секундами "s" и наносекундами "ns" - PISystemTime(int s, int ns) {seconds = s; nanoseconds = ns; checkOverflows();} - - - //! \~english Returns time value in seconds - //! \~russian Возвращает значение времени в секундах - double toSeconds() const {return double(seconds) + nanoseconds / 1.e+9;} - - //! \~english Returns time value in milliseconds - //! \~russian Возвращает значение времени в миллисекундах - double toMilliseconds() const {return seconds * 1.e+3 + nanoseconds / 1.e+6;} - - //! \~english Returns time value in microseconds - //! \~russian Возвращает значение времени в микросекундах - double toMicroseconds() const {return seconds * 1.e+6 + nanoseconds / 1.e+3;} - - //! \~english Returns time value in nanoseconds - //! \~russian Возвращает значение времени в наносекундах - double toNanoseconds() const {return seconds * 1.e+9 + double(nanoseconds);} - - - //! \~english Add to time "v" seconds - //! \~russian Добавляет ко времени "v" секунд - PISystemTime & addSeconds(double v) {*this += fromSeconds(v); return *this;} - - //! \~english Add to time "v" milliseconds - //! \~russian Добавляет ко времени "v" миллисекунд - PISystemTime & addMilliseconds(double v) {*this += fromMilliseconds(v); return *this;} - - //! \~english Add to time "v" microseconds - //! \~russian Добавляет ко времени "v" микросекунд - PISystemTime & addMicroseconds(double v) {*this += fromMicroseconds(v); return *this;} - - //! \~english Add to time "v" nanoseconds - //! \~russian Добавляет ко времени "v" наносекунд - PISystemTime & addNanoseconds(double v) {*this += fromNanoseconds(v); return *this;} - - - //! Sleep for stored value. \warning Use this function to sleep for difference of system times or constructs system time. - //! If you call this function on system time returned with \a PISystemTime::current() thread will be sleep almost forever. - //! \~english - //! \~russian - void sleep() {piUSleep(piFloord(toMicroseconds()));} // wait self value, useful to wait some dT = (t1 - t0) - - //! \~english On *nix system assign current value to timespec struct - //! \~russian На *nix системах присваивает время к timespec структуре - void toTimespec(void * ts); - - //! \~english Returns copy of this time with absolutely values of s and ns - //! \~russian Возвращает копию времени с модулем значения - PISystemTime abs() const; - - //! \~english Returns sum of this time with "t" - //! \~russian Возвращает сумму этого времени с "t" - PISystemTime operator +(const PISystemTime & t) const {PISystemTime tt(*this); tt.seconds += t.seconds; tt.nanoseconds += t.nanoseconds; tt.checkOverflows(); return tt;} - - //! \~english Returns difference between this time and "t" - //! \~russian Возвращает разницу между этим временем и "t" - PISystemTime operator -(const PISystemTime & t) const {PISystemTime tt(*this); tt.seconds -= t.seconds; tt.nanoseconds -= t.nanoseconds; tt.checkOverflows(); return tt;} - - //! \~english Returns multiplication between this time and "t" - //! \~russian Возвращает это временя умноженное на "t" - PISystemTime operator *(const double & v) const {return fromMilliseconds(toMilliseconds() * v);} - - //! \~english Returns division between this time and "t" - //! \~russian Возвращает это временя поделённое на "t" - PISystemTime operator /(const double & v) const {return fromMilliseconds(toMilliseconds() / v);} - - //! \~english Add to time "t" - //! \~russian Добавляет ко времени "t" - PISystemTime & operator +=(const PISystemTime & t) {seconds += t.seconds; nanoseconds += t.nanoseconds; checkOverflows(); return *this;} - - //! \~english Subtract from time "t" - //! \~russian Вычитает из времени "t" - PISystemTime & operator -=(const PISystemTime & t) {seconds -= t.seconds; nanoseconds -= t.nanoseconds; checkOverflows(); return *this;} - - //! \~english Multiply time by "v" - //! \~russian Умножает время на "v" - PISystemTime & operator *=(const double & v) {*this = fromMilliseconds(toMilliseconds() * v); return *this;} - - //! \~english Divide time by "v" - //! \~russian Делит время на "v" - PISystemTime & operator /=(const double & v) {*this = fromMilliseconds(toMilliseconds() / v); return *this;} - - - //! \~english Compare operator - //! \~russian Оператор сравнения - bool operator ==(const PISystemTime & t) const {return ((seconds == t.seconds) && (nanoseconds == t.nanoseconds));} - - //! \~english Compare operator - //! \~russian Оператор сравнения - bool operator !=(const PISystemTime & t) const {return ((seconds != t.seconds) || (nanoseconds != t.nanoseconds));} - - //! \~english Compare operator - //! \~russian Оператор сравнения - bool operator >(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds > t.nanoseconds; return seconds > t.seconds;} - - //! \~english Compare operator - //! \~russian Оператор сравнения - bool operator <(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds < t.nanoseconds; return seconds < t.seconds;} - - //! \~english Compare operator - //! \~russian Оператор сравнения - bool operator >=(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds >= t.nanoseconds; return seconds >= t.seconds;} - - //! \~english Compare operator - //! \~russian Оператор сравнения - bool operator <=(const PISystemTime & t) const {if (seconds == t.seconds) return nanoseconds <= t.nanoseconds; return seconds <= t.seconds;} - - - //! \~english Contructs time from seconds "v" - //! \~russian Создает время из "v" секунд - static PISystemTime fromSeconds(double v) {int s = piFloord(v); return PISystemTime(s, int((v - s) * 1000000000.));} - - //! \~english Contructs time from milliseconds "v" - //! \~russian Создает время из "v" миллисекунд - static PISystemTime fromMilliseconds(double v) {int s = piFloord(v / 1000.); return PISystemTime(s, int((v / 1000. - s) * 1000000000.));} - - //! \~english Contructs time from microseconds "v" - //! \~russian Создает время из "v" микросекунд - static PISystemTime fromMicroseconds(double v) {int s = piFloord(v / 1000000.); return PISystemTime(s, int((v / 1000000. - s) * 1000000000.));} - - //! \~english Contructs time from nanoseconds "v" - //! \~russian Создает время из "v" наносекунд - static PISystemTime fromNanoseconds(double v) {int s = piFloord(v / 1000000000.); return PISystemTime(s, int((v / 1000000000. - s) * 1000000000.));} - - //! \~english Returns current system time - //! \~russian Возвращает текущее системное время - static PISystemTime current(bool precise_but_not_system = false); - - //! \~english Seconds time part - //! \~russian Секунды времени - int seconds; - - //! \~english Nanoseconds time part - //! \~russian Наносекунды времени - int nanoseconds; - -private: - void checkOverflows() {while (nanoseconds >= 1000000000) {nanoseconds -= 1000000000; seconds++;} while (nanoseconds < 0) {nanoseconds += 1000000000; seconds--;}} - -}; - -//! \relatesalso PICout -//! \~english \brief Output operator to PICout -//! \~russian \brief Оператор вывода в PICout -inline PICout operator <<(PICout s, const PISystemTime & v) {s.space(); s.setControl(0, true); s << "(" << v.seconds << " s, " << v.nanoseconds << " ns)"; s.restoreControl(); return s;} - - - -struct PIP_EXPORT PITime { - PITime(int hours_ = 0, int minutes_ = 0, int seconds_ = 0, int milliseconds_ = 0): hours(hours_), minutes(minutes_), seconds(seconds_), milliseconds(milliseconds_) {;} - int hours; - int minutes; - int seconds; - int milliseconds; - PIString toString(const PIString & format = "h:mm:ss") const; - PISystemTime toSystemTime() const; - static PITime current(); - static PITime fromSystemTime(const PISystemTime & st); -}; - -PIP_EXPORT bool operator ==(const PITime & t0, const PITime & t1); -PIP_EXPORT bool operator <(const PITime & t0, const PITime & t1); -PIP_EXPORT bool operator >(const PITime & t0, const PITime & t1); -inline bool operator !=(const PITime & t0, const PITime & t1) {return !(t0 == t1);} -inline bool operator <=(const PITime & t0, const PITime & t1) {return !(t0 > t1);} -inline bool operator >=(const PITime & t0, const PITime & t1) {return !(t0 < t1);} - -//! \relatesalso PICout -//! \~english \brief Output operator to PICout -//! \~russian \brief Оператор вывода в PICout -PIP_EXPORT PICout operator <<(PICout s, const PITime & v); - - - - -struct PIP_EXPORT PIDate { - PIDate(int year_ = 0, int month_ = 0, int day_ = 0): year(year_), month(month_), day(day_) {;} - int year; - int month; - int day; - PIString toString(const PIString & format = "d.MM.yyyy") const; - static PIDate current(); -}; - -PIP_EXPORT bool operator ==(const PIDate & t0, const PIDate & t1); -PIP_EXPORT bool operator <(const PIDate & t0, const PIDate & t1); -PIP_EXPORT bool operator >(const PIDate & t0, const PIDate & t1); -inline bool operator !=(const PIDate & t0, const PIDate & t1) {return !(t0 == t1);} -inline bool operator <=(const PIDate & t0, const PIDate & t1) {return !(t0 > t1);} -inline bool operator >=(const PIDate & t0, const PIDate & t1) {return !(t0 < t1);} - -//! \relatesalso PICout -//! \~english \brief Output operator to PICout -//! \~russian \brief Оператор вывода в PICout -PIP_EXPORT PICout operator <<(PICout s, const PIDate & v); - - - - -struct PIP_EXPORT PIDateTime { - PIDateTime() {year = month = day = hours = minutes = seconds = milliseconds = 0;} - PIDateTime(const PITime & time) {year = month = day = 0; hours = time.hours; minutes = time.minutes; seconds = time.seconds; milliseconds = time.milliseconds;} - PIDateTime(const PIDate & date) {year = date.year; month = date.month; day = date.day; hours = minutes = seconds = milliseconds = 0;} - PIDateTime(const PIDate & date, const PITime & time) {year = date.year; month = date.month; day = date.day; hours = time.hours; minutes = time.minutes; seconds = time.seconds; milliseconds = time.milliseconds;} - int year; - int month; - int day; - int hours; - int minutes; - int seconds; - int milliseconds; - PIDateTime normalized() const {return PIDateTime::fromSecondSinceEpoch(toSecondSinceEpoch());} - void normalize() {*this = normalized();} - PIString toString(const PIString & format = "h:mm:ss d.MM.yyyy") const; - time_t toSecondSinceEpoch() const; - PISystemTime toSystemTime() const {return PISystemTime(int(toSecondSinceEpoch()), milliseconds * 1000000);} - PIDate date() const {return PIDate(year, month, day);} - PITime time() const {return PITime(hours, minutes, seconds, milliseconds);} - void setDate(const PIDate & d) {year = d.year; month = d.month; day = d.day;} - void setTime(const PITime & t) {hours = t.hours; minutes = t.minutes; seconds = t.seconds; milliseconds = t.milliseconds;} - void operator +=(const PIDateTime & d1) {year += d1.year; month += d1.month; day += d1.day; hours += d1.hours; minutes += d1.minutes; seconds += d1.seconds; normalize();} - void operator -=(const PIDateTime & d1) {year -= d1.year; month -= d1.month; day -= d1.day; hours -= d1.hours; minutes -= d1.minutes; seconds -= d1.seconds; normalize();} - static PIDateTime fromSecondSinceEpoch(const time_t sec); - static PIDateTime fromSystemTime(const PISystemTime & st) {PIDateTime dt = fromSecondSinceEpoch(st.seconds); dt.milliseconds = piClampi(st.nanoseconds / 1000000, 0, 999); return dt;} - static PIDateTime current(); -}; - -inline PIDateTime operator +(const PIDateTime & d0, const PIDateTime & d1) {PIDateTime td = d0; td += d1; return td.normalized();} -inline PIDateTime operator -(const PIDateTime & d0, const PIDateTime & d1) {PIDateTime td = d0; td -= d1; return td.normalized();} -PIP_EXPORT bool operator ==(const PIDateTime & t0, const PIDateTime & t1); -PIP_EXPORT bool operator <(const PIDateTime & t0, const PIDateTime & t1); -PIP_EXPORT bool operator >(const PIDateTime & t0, const PIDateTime & t1); -inline bool operator !=(const PIDateTime & t0, const PIDateTime & t1) {return !(t0 == t1);} -inline bool operator <=(const PIDateTime & t0, const PIDateTime & t1) {return !(t0 > t1);} -inline bool operator >=(const PIDateTime & t0, const PIDateTime & t1) {return !(t0 < t1);} -inline PIByteArray & operator <<(PIByteArray & s, const PIDateTime & v) {s << v.year << v.month << v.day << v.hours << v.minutes << v.seconds << v.milliseconds; return s;} -inline PIByteArray & operator >>(PIByteArray & s, PIDateTime & v) {s >> v.year >> v.month >> v.day >> v.hours >> v.minutes >> v.seconds >> v.milliseconds; return s;} - -//! \relatesalso PICout -//! \~english \brief Output operator to PICout -//! \~russian \brief Оператор вывода в PICout -PIP_EXPORT PICout operator <<(PICout s, const PIDateTime & v); - - - - -class PIP_EXPORT PITimeMeasurer { -public: - PITimeMeasurer(); - - /** \brief Set internal time mark to current system time - * \details This function used for set start time mark. Later - * you can find out elapsed time from this time mark to any - * moment of time with \a elapsed_s(), \a elapsed_m(), - * \a elapsed_u() or \a elapsed_n() functions. - * \sa \a elapsed_s(), \a elapsed_m(), \a elapsed_u(), \a elapsed_n() */ - void reset() {t_st = PISystemTime::current(true);} - - //! \brief Returns nanoseconds elapsed from last \a reset() execution or from timer measurer creation. - double elapsed_n() const; - - //! \brief Returns microseconds elapsed from last \a reset() execution or from timer measurer creation. - double elapsed_u() const; - - //! \brief Returns milliseconds elapsed from last \a reset() execution or from timer measurer creation. - double elapsed_m() const; - - //! \brief Returns seconds elapsed from last \a reset() execution or from timer measurer creation. - double elapsed_s() const; - - //! \brief Returns PISystemTime elapsed from last \a reset() execution or from timer measurer creation. - PISystemTime elapsed() const; - - double reset_time_n() const {return t_st.toNanoseconds();} - double reset_time_u() const {return t_st.toMicroseconds();} - double reset_time_m() const {return t_st.toMilliseconds();} - double reset_time_s() const {return t_st.toSeconds();} - - //! \brief Returns time mark of last \a reset() execution or timer measurer creation. - PISystemTime reset_time() {return t_st;} - - //! \brief Returns nanoseconds representation of current system time. - static double elapsed_system_n() {return PISystemTime::current(true).toNanoseconds();} - - //! \brief Returns microseconds representation of current system time. - static double elapsed_system_u() {return PISystemTime::current(true).toMicroseconds();} - - //! \brief Returns milliseconds representation of current system time. - static double elapsed_system_m() {return PISystemTime::current(true).toMilliseconds();} - - //! \brief Returns seconds representation of current system time. - static double elapsed_system_s() {return PISystemTime::current(true).toSeconds();} - - //! \brief Returns time mark of current system time. - static PISystemTime elapsed_system() {return PISystemTime::current(true);} - -private: - PISystemTime t_st, t_cur; - -}; - #endif // PITIME_H diff --git a/libs/main/core/pitime_win.h b/libs/main/core/pitime_win.h index 053e727b..80aedd7f 100644 --- a/libs/main/core/pitime_win.h +++ b/libs/main/core/pitime_win.h @@ -1,7 +1,8 @@ /*! \file pitime_win.h - * \brief PITime conversions for Windows - * - * This file declare time conversions for Windows + * \ingroup Core + * \brief + * \~english PITime conversions for Windows + * \~russian Преобразования PITime для Windows */ /* PIP - Platform Independent Primitives diff --git a/libs/main/core/pivariant.h b/libs/main/core/pivariant.h index 9cf38c4c..7840e06f 100644 --- a/libs/main/core/pivariant.h +++ b/libs/main/core/pivariant.h @@ -1,7 +1,8 @@ /*! \file pivariant.h - * \brief Variant type - * - * This file declares PIVariant + * \ingroup Core + * \brief + * \~english Variant type + * \~russian Вариативный тип */ /* PIP - Platform Independent Primitives diff --git a/libs/main/core/pivariantsimple.h b/libs/main/core/pivariantsimple.h index 70a79f29..59d746bd 100644 --- a/libs/main/core/pivariantsimple.h +++ b/libs/main/core/pivariantsimple.h @@ -1,7 +1,8 @@ /*! \file pivariantsimple.h - * \brief Variant simple type - * - * This file declares PIVariantSimple + * \ingroup Core + * \brief + * \~english Variant simple type + * \~russian Простой вариативный тип */ /* PIP - Platform Independent Primitives diff --git a/libs/main/core/pivarianttypes.h b/libs/main/core/pivarianttypes.h index 6bafe682..00342f31 100644 --- a/libs/main/core/pivarianttypes.h +++ b/libs/main/core/pivarianttypes.h @@ -1,7 +1,8 @@ /*! \file pivarianttypes.h - * \brief Variant type - * - * This file declares PIVariant + * \ingroup Core + * \brief + * \~english Types for PIVariant + * \~russian Типы для PIVariant */ /* PIP - Platform Independent Primitives