duration.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <chrono>
#include <cstdint>
#include <type_traits>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/rational.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Error;
class String;
class DataStream;
 
class Duration {
        public:
                PROMEKI_DATATYPE(Duration, DataTypeDuration, 1)
 
                
                static constexpr int64_t Invalid = INT64_MIN;
 
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<Duration> readFromStream(DataStream &s);
 
                static Duration zero() { return Duration(int64_t{0}); }
 
                static Duration fromHours(int64_t h) {
                        return Duration(h * 3'600'000'000'000LL);
                }
 
                static Duration fromMinutes(int64_t m) {
                        return Duration(m * 60'000'000'000LL);
                }
 
                static Duration fromSeconds(int64_t s) {
                        return Duration(s * 1'000'000'000LL);
                }
 
                static Duration fromMilliseconds(int64_t ms) {
                        return Duration(ms * 1'000'000LL);
                }
 
                static Duration fromMicroseconds(int64_t us) {
                        return Duration(us * 1'000LL);
                }
 
                static Duration fromNanoseconds(int64_t ns) { return Duration(ns); }
 
                template <typename Int, std::enable_if_t<std::is_integral_v<Int>, int> = 0>
                static Duration fromSamples(int64_t count, Int rate) {
                        if (rate == 0) return zero();
                        return fromNanoseconds(count * 1'000'000'000LL / static_cast<int64_t>(rate));
                }
 
                template <typename Float, std::enable_if_t<std::is_floating_point_v<Float>, int> = 0>
                static Duration fromSamples(int64_t count, Float rate) {
                        if (!(rate > Float(0))) return zero();
                        const double ns = static_cast<double>(count) * 1'000'000'000.0 / static_cast<double>(rate);
                        return fromNanoseconds(static_cast<int64_t>(ns));
                }
 
                template <typename T> static Duration fromSamples(int64_t count, const Rational<T> &rate) {
                        if (!rate.isValid() || rate.numerator() == 0) {
                                return zero();
                        }
                        const int64_t num = static_cast<int64_t>(rate.numerator());
                        const int64_t den = static_cast<int64_t>(rate.denominator());
                        return fromNanoseconds(count * den * 1'000'000'000LL / num);
                }
 
                Duration() = default;
 
                bool isValid() const { return _ns != Invalid; }
 
                int64_t hours() const { return isValid() ? _ns / 3'600'000'000'000LL : 0; }
 
                int64_t minutes() const { return isValid() ? _ns / 60'000'000'000LL : 0; }
 
                int64_t seconds() const { return isValid() ? _ns / 1'000'000'000LL : 0; }
 
                int64_t milliseconds() const { return isValid() ? _ns / 1'000'000LL : 0; }
 
                int64_t microseconds() const { return isValid() ? _ns / 1'000LL : 0; }
 
                int64_t nanoseconds() const { return _ns; }
 
                double toSecondsDouble() const {
                        return isValid() ? static_cast<double>(_ns) / 1'000'000'000.0 : 0.0;
                }
 
                bool isZero() const { return _ns == 0; }
 
                bool isNegative() const { return isValid() && _ns < 0; }
 
                String toString() const;
 
                static Result<Duration> fromString(const String &str);
 
                String toScaledString(int precision = 2) const;
 
                Duration operator+(const Duration &o) const {
                        if (!isValid() || !o.isValid()) return Duration();
                        return Duration(_ns + o._ns);
                }
                Duration operator-(const Duration &o) const {
                        if (!isValid() || !o.isValid()) return Duration();
                        return Duration(_ns - o._ns);
                }
                Duration operator*(int64_t s) const {
                        if (!isValid()) return Duration();
                        return Duration(_ns * s);
                }
                Duration operator/(int64_t s) const {
                        if (!isValid()) return Duration();
                        return Duration(_ns / s);
                }
                Duration operator-() const {
                        if (!isValid()) return Duration();
                        return Duration(-_ns);
                }
 
                bool operator==(const Duration &o) const { return _ns == o._ns; }
                bool operator!=(const Duration &o) const { return _ns != o._ns; }
                bool operator<(const Duration &o) const { return _ns < o._ns; }
                bool operator>(const Duration &o) const { return _ns > o._ns; }
                bool operator<=(const Duration &o) const { return _ns <= o._ns; }
                bool operator>=(const Duration &o) const { return _ns >= o._ns; }
 
        private:
                explicit Duration(int64_t ns) : _ns(ns) {}
                int64_t _ns = Invalid;
};
 
PROMEKI_NAMESPACE_END
 
template <> struct std::formatter<promeki::Duration> {
                enum class Style {
                        Hms,
                        Scaled
                };
 
                Style                            _style = Style::Hms;
                std::formatter<std::string_view> _base;
 
                constexpr auto parse(std::format_parse_context &ctx) {
                        auto it = ctx.begin();
                        auto end = ctx.end();
 
                        auto tryKeyword = [&](const char *kw, Style s) {
                                auto p = it;
                                while (*kw && p != end && *p == *kw) {
                                        ++p;
                                        ++kw;
                                }
                                if (*kw == 0 && (p == end || *p == '}' || *p == ':')) {
                                        it = p;
                                        _style = s;
                                        return true;
                                }
                                return false;
                        };
 
                        if (!tryKeyword("scaled", Style::Scaled)) {
                                tryKeyword("hms", Style::Hms);
                        }
 
                        if (it != end && *it == ':') ++it;
 
                        ctx.advance_to(it);
                        return _base.parse(ctx);
                }
 
                template <typename FormatContext> auto format(const promeki::Duration &d, FormatContext &ctx) const {
                        promeki::String s = (_style == Style::Scaled) ? d.toScaledString() : d.toString();
                        return _base.format(std::string_view(s.cstr(), s.byteCount()), ctx);
                }
};
 
#endif // PROMEKI_ENABLE_CORE