#pragma once
#include <memory>
#include <wtf/FastMalloc.h>
namespace WTF {
template<typename> class Function;
template <typename Out, typename... In>
class Function<Out(In...)> {
public:
Function() = default;
Function(std::nullptr_t) { }
template<typename CallableType, class = typename std::enable_if<!(std::is_pointer<CallableType>::value && std::is_function<typename std::remove_pointer<CallableType>::type>::value) && std::is_rvalue_reference<CallableType&&>::value>::type>
Function(CallableType&& callable)
: m_callableWrapper(std::make_unique<CallableWrapper<CallableType>>(WTFMove(callable)))
{
}
template<typename FunctionType, class = typename std::enable_if<std::is_pointer<FunctionType>::value && std::is_function<typename std::remove_pointer<FunctionType>::type>::value>::type>
Function(FunctionType f)
: m_callableWrapper(std::make_unique<CallableWrapper<FunctionType>>(WTFMove(f)))
{
}
Out operator()(In... in) const
{
if (m_callableWrapper)
return m_callableWrapper->call(std::forward<In>(in)...);
return Out();
}
explicit operator bool() const { return !!m_callableWrapper; }
template<typename CallableType, class = typename std::enable_if<!(std::is_pointer<CallableType>::value && std::is_function<typename std::remove_pointer<CallableType>::type>::value) && std::is_rvalue_reference<CallableType&&>::value>::type>
Function& operator=(CallableType&& callable)
{
m_callableWrapper = std::make_unique<CallableWrapper<CallableType>>(WTFMove(callable));
return *this;
}
template<typename FunctionType, class = typename std::enable_if<std::is_pointer<FunctionType>::value && std::is_function<typename std::remove_pointer<FunctionType>::type>::value>::type>
Function& operator=(FunctionType f)
{
m_callableWrapper = std::make_unique<CallableWrapper<FunctionType>>(WTFMove(f));
return *this;
}
Function& operator=(std::nullptr_t)
{
m_callableWrapper = nullptr;
return *this;
}
private:
class CallableWrapperBase {
WTF_MAKE_FAST_ALLOCATED;
public:
virtual ~CallableWrapperBase() { }
virtual Out call(In...) = 0;
};
template<typename CallableType>
class CallableWrapper : public CallableWrapperBase {
public:
explicit CallableWrapper(CallableType&& callable)
: m_callable(WTFMove(callable))
{
}
CallableWrapper(const CallableWrapper&) = delete;
CallableWrapper& operator=(const CallableWrapper&) = delete;
Out call(In... in) final { return m_callable(std::forward<In>(in)...); }
private:
CallableType m_callable;
};
std::unique_ptr<CallableWrapperBase> m_callableWrapper;
};
}
using WTF::Function;