Timeout.h

Go to the documentation of this file.

 
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef TASKOLIB_TIMEOUT_H_
#define TASKOLIB_TIMEOUT_H_
 
#include <chrono>
#include <cmath>
#include <limits>
#include <ostream>
 
#include "taskolib/exceptions.h"
 
namespace task {
 
class Timeout
{
public:
    using Duration = std::chrono::milliseconds;
 
    Timeout() = default;
 
    template <typename Rep, typename Period>
    constexpr
    Timeout(std::chrono::duration<Rep, Period> duration)
    {
        if (duration < duration.zero())
            throw Error("Negative timeout");
 
        if (duration >= infinite_duration)
            timeout_ = infinite_duration;
        else
            timeout_ = std::chrono::round<Duration>(duration);
    }
 
    template <typename FloatT,
              std::enable_if_t<std::is_floating_point<FloatT>::value, bool> = true>
    explicit constexpr
    Timeout(FloatT seconds)
    {
        if (seconds < FloatT{ 0.0 })
            throw Error("Negative timeout");
 
        if (std::isnan(seconds))
            throw Error("Timeout is not-a-number");
 
        const auto desired_duration = std::chrono::duration<FloatT>{ seconds };
 
        if (not std::isfinite(seconds) || desired_duration >= infinite_duration)
            timeout_ = infinite_duration;
        else
            timeout_ = std::chrono::round<Duration>(desired_duration);
    }
 
    static constexpr Timeout infinity() { return Timeout{ infinite_duration }; };
 
    friend bool isfinite(Timeout timeout) noexcept
    {
        return timeout.timeout_ < infinite_duration;
    }
 
    friend constexpr bool
    operator==(Timeout lhs, Timeout rhs) { return lhs.timeout_ == rhs.timeout_; }
 
    friend constexpr bool
    operator!=(Timeout lhs, Timeout rhs) { return lhs.timeout_ != rhs.timeout_; }
 
    friend constexpr bool
    operator> (Timeout lhs, Timeout rhs) { return lhs.timeout_ >  rhs.timeout_; }
 
    friend constexpr bool
    operator< (Timeout lhs, Timeout rhs) { return lhs.timeout_ <  rhs.timeout_; }
 
    friend constexpr bool
    operator>=(Timeout lhs, Timeout rhs) { return lhs.timeout_ >= rhs.timeout_; }
 
    friend constexpr bool
    operator<=(Timeout lhs, Timeout rhs) { return lhs.timeout_ <= rhs.timeout_; }
 
    template <typename FloatT,
              std::enable_if_t<std::is_floating_point<FloatT>::value, bool> = true>
    operator FloatT() const
    {
        if (isfinite(*this))
            return std::chrono::duration_cast<std::chrono::duration<FloatT>>(timeout_).count();
        else
            return std::numeric_limits<FloatT>::infinity();
    }
 
    template <typename DurationT,
              std::enable_if_t<std::is_arithmetic_v<typename DurationT::rep>, bool> = true>
    operator DurationT() const
    {
        if (isfinite(*this))
            return std::chrono::duration_cast<DurationT>(timeout_);
        else
            return DurationT::max();
    }
 
private:
    static constexpr Duration infinite_duration{ Duration::max() };
 
    Duration timeout_{ infinite_duration };
};
 
inline std::ostream& operator<<(std::ostream& stream, const Timeout& timeout) {
    if (!isfinite(timeout))
        stream << "infinite";
    else
        stream << static_cast<std::chrono::milliseconds>(timeout).count();
    return stream;
}
 
} // namespace task
 
#endif