mirror of
https://github.com/matrix-construct/construct
synced 2024-09-08 17:55:47 +02:00
This is not a move to c++17. If the compiler happens to have support for c++17 namespace scope resolution, they have been kind enough to backport it to gnu++14. This limits our support for really old c++14 compilers, but that was limited anyway. GCC 6.1 and clang 3.6 tested.
222 lines
5.5 KiB
C++
222 lines
5.5 KiB
C++
/*
|
|
* Copyright (C) 2016 Charybdis Development Team
|
|
* Copyright (C) 2016 Jason Volk <jason@zemos.net>
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice is present in all copies.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#pragma once
|
|
#define HAVE_IRCD_CTX_FUTURE_H
|
|
|
|
namespace ircd::ctx
|
|
{
|
|
template<class T = void> class future;
|
|
template<> class future<void>;
|
|
template<class... T> struct scoped_future;
|
|
|
|
enum class future_status;
|
|
|
|
template<class T,
|
|
class time_point>
|
|
future_status wait_until(const future<T> &, const time_point &);
|
|
}
|
|
|
|
enum class ircd::ctx::future_status
|
|
{
|
|
ready,
|
|
timeout,
|
|
deferred,
|
|
};
|
|
|
|
template<class T>
|
|
class ircd::ctx::future
|
|
{
|
|
std::shared_ptr<shared_state<T>> st;
|
|
|
|
public:
|
|
using value_type = typename shared_state<T>::value_type;
|
|
using pointer_type = typename shared_state<T>::pointer_type;
|
|
using reference_type = typename shared_state<T>::reference_type;
|
|
|
|
bool valid() const { return bool(st); }
|
|
bool operator!() const { return !valid(); }
|
|
operator bool() const { return valid(); }
|
|
|
|
template<class U, class time_point> friend future_status wait_until(const future<U> &, const time_point &);
|
|
template<class time_point> future_status wait_until(const time_point &) const;
|
|
template<class duration> future_status wait(const duration &d) const;
|
|
void wait() const;
|
|
|
|
T get();
|
|
operator T() { return get(); }
|
|
|
|
future();
|
|
future(promise<T> &promise);
|
|
};
|
|
|
|
template<>
|
|
class ircd::ctx::future<void>
|
|
{
|
|
std::shared_ptr<shared_state<void>> st;
|
|
|
|
public:
|
|
using value_type = typename shared_state<void>::value_type;
|
|
|
|
bool valid() const { return bool(st); }
|
|
bool operator!() const { return !valid(); }
|
|
operator bool() const { return valid(); }
|
|
|
|
template<class U, class time_point> friend future_status wait_until(const future<U> &, const time_point &);
|
|
template<class time_point> future_status wait_until(const time_point &) const;
|
|
template<class duration> future_status wait(const duration &d) const;
|
|
void wait() const;
|
|
|
|
future();
|
|
future(promise<void> &promise);
|
|
};
|
|
|
|
template<class... T>
|
|
struct ircd::ctx::scoped_future
|
|
:future<T...>
|
|
{
|
|
template<class... Args> scoped_future(Args&&... args);
|
|
~scoped_future() noexcept;
|
|
};
|
|
|
|
template<class... T>
|
|
template<class... Args>
|
|
ircd::ctx::scoped_future<T...>::scoped_future(Args&&... args)
|
|
:future<T...>{std::forward<Args>(args)...}
|
|
{
|
|
}
|
|
|
|
template<class... T>
|
|
ircd::ctx::scoped_future<T...>::~scoped_future()
|
|
noexcept
|
|
{
|
|
if(std::uncaught_exception())
|
|
return;
|
|
|
|
if(this->valid())
|
|
this->wait();
|
|
}
|
|
|
|
inline
|
|
ircd::ctx::future<void>::future():
|
|
st(nullptr)
|
|
{
|
|
}
|
|
|
|
template<class T>
|
|
ircd::ctx::future<T>::future():
|
|
st(nullptr)
|
|
{
|
|
}
|
|
|
|
inline
|
|
ircd::ctx::future<void>::future(promise<void> &promise):
|
|
st(promise.get_state().share())
|
|
{
|
|
}
|
|
|
|
template<class T>
|
|
ircd::ctx::future<T>::future(promise<T> &promise):
|
|
st(promise.get_state().share())
|
|
{
|
|
}
|
|
|
|
template<class T>
|
|
T
|
|
ircd::ctx::future<T>::get()
|
|
{
|
|
wait();
|
|
|
|
if(unlikely(bool(st->eptr)))
|
|
std::rethrow_exception(st->eptr);
|
|
|
|
return st->val;
|
|
}
|
|
|
|
inline void
|
|
ircd::ctx::future<void>::wait()
|
|
const
|
|
{
|
|
this->wait_until(steady_clock::time_point::max());
|
|
}
|
|
|
|
template<class T>
|
|
void
|
|
ircd::ctx::future<T>::wait()
|
|
const
|
|
{
|
|
this->wait_until(steady_clock::time_point::max());
|
|
}
|
|
|
|
template<class duration>
|
|
ircd::ctx::future_status
|
|
ircd::ctx::future<void>::wait(const duration &d)
|
|
const
|
|
{
|
|
return this->wait_until(steady_clock::now() + d);
|
|
}
|
|
|
|
template<class T>
|
|
template<class duration>
|
|
ircd::ctx::future_status
|
|
ircd::ctx::future<T>::wait(const duration &d)
|
|
const
|
|
{
|
|
return this->wait_until(steady_clock::now() + d);
|
|
}
|
|
|
|
template<class T>
|
|
template<class time_point>
|
|
ircd::ctx::future_status
|
|
ircd::ctx::future<T>::wait_until(const time_point &tp)
|
|
const
|
|
{
|
|
return ircd::ctx::wait_until(*this, tp);
|
|
}
|
|
|
|
template<class time_point>
|
|
ircd::ctx::future_status
|
|
ircd::ctx::future<void>::wait_until(const time_point &tp)
|
|
const
|
|
{
|
|
return ircd::ctx::wait_until(*this, tp);
|
|
}
|
|
|
|
template<class T,
|
|
class time_point>
|
|
ircd::ctx::future_status
|
|
ircd::ctx::wait_until(const future<T> &f,
|
|
const time_point &tp)
|
|
{
|
|
const auto wfun([&f]() -> bool
|
|
{
|
|
return f.st->finished;
|
|
});
|
|
|
|
if(unlikely(!f.valid()))
|
|
throw no_state();
|
|
|
|
if(unlikely(!f.st->cond.wait_until(tp, wfun)))
|
|
return future_status::timeout;
|
|
|
|
return likely(wfun())? future_status::ready:
|
|
future_status::deferred;
|
|
}
|