duration.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_CHRONO_DURATION_HPP
#define TETL_CHRONO_DURATION_HPP
 
#include <etl/_chrono/duration_values.hpp>
#include <etl/_chrono/treat_as_floating_point.hpp>
#include <etl/_cstdint/int_least_t.hpp>
#include <etl/_numeric/gcd.hpp>
#include <etl/_numeric/lcm.hpp>
#include <etl/_ratio/ratio.hpp>
#include <etl/_ratio/ratio_divide.hpp>
#include <etl/_type_traits/common_type.hpp>
#include <etl/_type_traits/is_convertible.hpp>
 
namespace etl::chrono {


template <typename Rep, typename Period = etl::ratio<1>>
struct duration {
    using rep = Rep;

    using period = typename Period::type;

    constexpr duration() noexcept = default;

    constexpr duration(duration const&) noexcept = default;

    template <typename Rep2>
        requires(is_convertible_v<Rep2, rep> and (treat_as_floating_point_v<rep> or !treat_as_floating_point_v<Rep2>))
    constexpr explicit duration(Rep2 const& r) noexcept
        : _rep(r)
    {
    }

    template <typename Rep2, typename Period2>
        requires(
            treat_as_floating_point_v<rep>
            or (ratio_divide<Period2, period>::den == 1 and not treat_as_floating_point_v<Rep2>)
        )
    constexpr duration(duration<Rep2, Period2> const& other) noexcept
        : _rep(static_cast<Rep>(other.count() * ratio_divide<Period2, period>::num))
    {
    }

    auto operator=(duration const& other) -> duration& = default;

    [[nodiscard]] constexpr auto count() const -> rep { return _rep; }

    [[nodiscard]] static constexpr auto zero() noexcept -> duration
    {
        return duration(etl::chrono::duration_values<rep>::zero());
    }

    [[nodiscard]] static constexpr auto min() noexcept -> duration
    {
        return duration(etl::chrono::duration_values<rep>::min());
    }

    [[nodiscard]] static constexpr auto max() noexcept -> duration
    {
        return duration(etl::chrono::duration_values<rep>::max());
    }

    [[nodiscard]] constexpr auto operator+() const -> etl::common_type_t<duration>
    {
        return etl::common_type_t<duration>(*this);
    }

    [[nodiscard]] constexpr auto operator-() const -> etl::common_type_t<duration>
    {
        return etl::common_type_t<duration>(-_rep);
    }

    constexpr auto operator++() -> duration&
    {
        ++_rep;
        return *this;
    }

    constexpr auto operator++(int) -> duration { return duration(_rep++); }

    constexpr auto operator--() -> duration&
    {
        --_rep;
        return *this;
    }

    constexpr auto operator--(int) -> duration { return duration(_rep--); }

    constexpr auto operator+=(duration const& d) noexcept -> duration&
    {
        _rep += d.count();
        return *this;
    }

    constexpr auto operator-=(duration const& d) noexcept -> duration&
    {
        _rep -= d.count();
        return *this;
    }

    constexpr auto operator*=(rep const& rhs) noexcept -> duration&
    {
        _rep *= rhs;
        return *this;
    }

    constexpr auto operator/=(rep const& rhs) noexcept -> duration&
    {
        _rep /= rhs;
        return *this;
    }

    constexpr auto operator%=(rep const& rhs) noexcept -> duration&
    {
        _rep %= rhs;
        return *this;
    }

    constexpr auto operator%=(duration const& rhs) noexcept -> duration&
    {
        _rep %= rhs.count();
        return *this;
    }
 
private:
    rep _rep{};
};
 
} // namespace etl::chrono
 
namespace etl {

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> {
private:
    static constexpr auto num = gcd(Period1::num, Period2::num);
    static constexpr auto den = lcm(Period1::den, Period2::den);
 
public:
    using type = chrono::duration<common_type_t<Rep1, Rep2>, ratio<num, den>>;
};
 
} // namespace etl
 
namespace etl::chrono {

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator+(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs)
    -> common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
{
    using CD = common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>;
    using CR = typename CD::rep;
    return CD(static_cast<CR>(CD(lhs).count() + CD(rhs).count()));
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator-(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs)
    -> common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
{
    using CD = common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>;
    using CR = typename CD::rep;
    return CD(static_cast<CR>(CD(lhs).count() - CD(rhs).count()));
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator/(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs)
    -> common_type_t<Rep1, Rep2>
{
    using CD = common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>;
    return CD(lhs).count() / CD(rhs).count();
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator%(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs)
    -> common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
{
    using CD = common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>;
    using CR = typename CD::rep;
    return CD(static_cast<CR>(CD(lhs).count() % CD(rhs).count()));
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator==(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs) -> bool
{
    using common_t = typename etl::common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type;
    return common_t(lhs).count() == common_t(rhs).count();
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator!=(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs) -> bool
{
    return !(lhs == rhs);
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator<(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs) -> bool
{
    using common_t = typename etl::common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type;
    return common_t(lhs).count() < common_t(rhs).count();
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator<=(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs) -> bool
{
    return !(rhs < lhs);
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator>(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs) -> bool
{
    return rhs < lhs;
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
[[nodiscard]] constexpr auto operator>=(duration<Rep1, Period1> const& lhs, duration<Rep2, Period2> const& rhs) -> bool
{
    return !(lhs < rhs);
}

using nanoseconds = duration<int_least64_t, nano>;

using microseconds = duration<int_least64_t, micro>;

using milliseconds = duration<int_least64_t, milli>;

using seconds = duration<int_least64_t>;

using minutes = duration<int_least32_t, ratio<60>>;

using hours = duration<int_least32_t, ratio<3600>>;

using days = duration<int_least32_t, ratio<86400>>;

using weeks = duration<int_least32_t, ratio<604800>>;

using months = duration<int_least32_t, ratio<31556952>>;

using years = duration<int_least32_t, ratio<2629746>>;

 
} // namespace etl::chrono
 
// NOLINTNEXTLINE(modernize-concat-nested-namespaces)
namespace etl {
 
inline namespace literals {
inline namespace chrono_literals {

constexpr auto operator""_h(unsigned long long h) -> etl::chrono::hours
{
    return etl::chrono::hours(static_cast<etl::chrono::hours::rep>(h));
}

constexpr auto operator""_h(long double h) -> etl::chrono::duration<long double, ratio<3600, 1>>
{
    return etl::chrono::duration<long double, etl::ratio<3600, 1>>(h);
}

constexpr auto operator""_min(unsigned long long m) -> etl::chrono::minutes
{
    return etl::chrono::minutes(static_cast<etl::chrono::minutes::rep>(m));
}

constexpr auto operator""_min(long double m) -> etl::chrono::duration<long double, etl::ratio<60, 1>>
{
    return etl::chrono::duration<long double, ratio<60, 1>>(m);
}

constexpr auto operator""_s(unsigned long long m) -> etl::chrono::seconds
{
    return etl::chrono::seconds(static_cast<etl::chrono::seconds::rep>(m));
}

constexpr auto operator""_s(long double m) -> etl::chrono::duration<long double>
{
    return etl::chrono::duration<long double>(m);
}

constexpr auto operator""_ms(unsigned long long m) -> etl::chrono::milliseconds
{
    return etl::chrono::milliseconds(static_cast<etl::chrono::milliseconds::rep>(m));
}

constexpr auto operator""_ms(long double m) -> etl::chrono::duration<long double, etl::milli>
{
    return etl::chrono::duration<long double, etl::milli>(m);
}

constexpr auto operator""_us(unsigned long long m) -> etl::chrono::microseconds
{
    return etl::chrono::microseconds(static_cast<etl::chrono::microseconds::rep>(m));
}

constexpr auto operator""_us(long double m) -> etl::chrono::duration<long double, etl::micro>
{
    return etl::chrono::duration<long double, etl::micro>(m);
}

constexpr auto operator""_ns(unsigned long long m) -> etl::chrono::nanoseconds
{
    return etl::chrono::nanoseconds(static_cast<etl::chrono::nanoseconds::rep>(m));
}

constexpr auto operator""_ns(long double m) -> etl::chrono::duration<long double, etl::nano>
{
    return etl::chrono::duration<long double, etl::nano>(m);
}
 
} // namespace chrono_literals
} // namespace literals
} // namespace etl
 
namespace etl::chrono {
using namespace etl::literals::chrono_literals;
} // namespace etl::chrono
 
#endif // TETL_CHRONO_DURATION_HPP