time_point.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_CHRONO_TIME_POINT_HPP
#define TETL_CHRONO_TIME_POINT_HPP
 
#include <etl/_type_traits/common_type.hpp>
#include <etl/_type_traits/is_convertible.hpp>
 
namespace etl::chrono {

template <typename Clock, typename Duration = typename Clock::duration>
struct time_point {
    using clock = Clock;

    using duration = Duration;

    using rep = typename duration::rep;

    using period = typename duration::period;

    constexpr time_point() noexcept = default;

    constexpr explicit time_point(duration const& d) noexcept
        : _d{d}
    {
    }

    template <typename Dur2>
        requires(is_convertible_v<Dur2, duration>)
    constexpr time_point(time_point<clock, Dur2> const& t)
        : _d{t.time_since_epch()}
    {
    }

    [[nodiscard]] constexpr auto time_since_epoch() const noexcept -> duration { return _d; }

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

    constexpr auto operator-=(duration const& d) noexcept -> time_point&
    {
        _d -= d;
        return *this;
    }

    constexpr auto operator++() noexcept -> time_point&
    {
        ++_d;
        return *this;
    }

    constexpr auto operator++(int) noexcept -> time_point { return time_point(_d++); }

    constexpr auto operator--() noexcept -> time_point&
    {
        --_d;
        return *this;
    }

    constexpr auto operator--(int) noexcept -> time_point { return time_point(_d--); }

    [[nodiscard]] static constexpr auto min() noexcept -> time_point { return time_point(duration::min()); }

    [[nodiscard]] static constexpr auto max() noexcept -> time_point { return time_point(duration::max()); }
 
private:
    duration _d{};
};

template <typename Clock, typename Dur1, typename Dur2>
[[nodiscard]] constexpr auto operator==(time_point<Clock, Dur1> const& lhs, time_point<Clock, Dur2> const& rhs) noexcept
    -> bool
{
    return lhs.time_since_epoch() == rhs.time_since_epoch();
}

template <typename Clock, typename Dur1, typename Dur2>
[[nodiscard]] constexpr auto operator<(time_point<Clock, Dur1> const& lhs, time_point<Clock, Dur2> const& rhs) noexcept
    -> bool
{
    return lhs.time_since_epoch() < rhs.time_since_epoch();
}

template <typename Clock, typename Dur1, typename Dur2>
[[nodiscard]] constexpr auto operator<=(time_point<Clock, Dur1> const& lhs, time_point<Clock, Dur2> const& rhs) noexcept
    -> bool
{
    return lhs.time_since_epoch() <= rhs.time_since_epoch();
}

template <typename Clock, typename Dur1, typename Dur2>
[[nodiscard]] constexpr auto operator>(time_point<Clock, Dur1> const& lhs, time_point<Clock, Dur2> const& rhs) noexcept
    -> bool
{
    return lhs.time_since_epoch() > rhs.time_since_epoch();
}

template <typename Clock, typename Dur1, typename Dur2>
[[nodiscard]] constexpr auto operator>=(time_point<Clock, Dur1> const& lhs, time_point<Clock, Dur2> const& rhs) noexcept
    -> bool
{
    return lhs.time_since_epoch() >= rhs.time_since_epoch();
}
 
} // namespace etl::chrono
 
namespace etl {

template <typename Clock, typename Duration1, typename Duration2>
struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> {
    using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>;
};
 
} // namespace etl
 
#endif // TETL_CHRONO_TIME_POINT_HPP