asyncpp/include/asyncpp/timing/timeout/timeout_stream.inl

#pragma once

#include "timeout_stream.h"

namespace asyncpp {
namespace timing {

    /* timeout_stream */

    template<
        typename T_inner>
    template<
        typename X_inner,
        typename X_base,
        typename X_ratio>
    timeout_stream<T_inner>::timeout_stream(
        X_inner&&                           p_inner,
        const duration<X_base, X_ratio>&    p_timeout)
        : _inner    (std::forward<X_inner>(p_inner))
        , _timeout  (p_timeout)
        , _delay    (asyncpp::now() + p_timeout)
        { }

    template<
        typename T_inner>
    template<
        typename X_base,
        typename X_ratio>
    void timeout_stream<T_inner>
        ::reset(const duration<X_base, X_ratio>& p_timeout)
    {
        _timeout = p_timeout;
        _delay.reset(_timeout);
    }

    template<
        typename T_inner>
    typename timeout_stream<T_inner>::result_type
    timeout_stream<T_inner>
        ::poll()
    {
        auto r = _inner.poll();

        if (r.is_not_ready())
        {
            if (_delay.poll())
            {
                _delay.reset(_timeout);
                throw timing::timeout_exception();
            }
        }
        else
        {
            _delay.reset(_timeout);
        }

        return r;
    }

} }