132 lines
3.9 KiB
C++
132 lines
3.9 KiB
C++
/**
|
|
This file is a part of rexy's general purpose library
|
|
Copyright (C) 2022 rexy712
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef REXY_UTIL_DEFERRED_HPP
|
|
#define REXY_UTIL_DEFERRED_HPP
|
|
|
|
#include <tuple>
|
|
#include <utility> //forward, index_sequence
|
|
|
|
namespace rexy{
|
|
template<class T, class... Args>
|
|
class deferred
|
|
{
|
|
public:
|
|
using value_type = T;
|
|
|
|
private:
|
|
std::tuple<Args&&...> m_args;
|
|
|
|
public:
|
|
template<class... FArgs>
|
|
constexpr deferred(FArgs&&... args);
|
|
|
|
deferred(const deferred&) = default;
|
|
deferred(deferred&&) = default;
|
|
~deferred(void) = default;
|
|
deferred& operator=(const deferred&) = default;
|
|
deferred& operator=(deferred&&) = default;
|
|
|
|
constexpr value_type value(void);
|
|
constexpr operator value_type(void);
|
|
|
|
private:
|
|
template<std::size_t... Is>
|
|
constexpr value_type get_value_(std::index_sequence<Is...>);
|
|
};
|
|
|
|
template<class Fn, class... Args>
|
|
class deferred_function
|
|
{
|
|
public:
|
|
using ret_t = decltype(std::declval<Fn>()(std::declval<Args>()...));
|
|
|
|
private:
|
|
Fn m_fn;
|
|
std::tuple<Args&&...> m_args;
|
|
|
|
public:
|
|
template<class F, class... FArgs>
|
|
constexpr deferred_function(F&& f, FArgs&&... args);
|
|
|
|
constexpr decltype(auto) operator()(void);
|
|
|
|
constexpr decltype(auto) value(void);
|
|
constexpr operator ret_t(void);
|
|
|
|
private:
|
|
template<std::size_t... Is>
|
|
constexpr decltype(auto) get_value_(std::index_sequence<Is...>);
|
|
};
|
|
|
|
template<class T, class... Args>
|
|
template<class... FArgs>
|
|
constexpr deferred<T,Args...>::deferred(FArgs&&... args):
|
|
m_args{std::forward<FArgs>(args)...}{}
|
|
template<class T, class... Args>
|
|
constexpr auto deferred<T,Args...>::value(void) -> value_type{
|
|
return get_value_(std::make_index_sequence<sizeof...(Args)>());
|
|
}
|
|
template<class T, class... Args>
|
|
constexpr deferred<T,Args...>::operator value_type(void){
|
|
return get_value_(std::make_index_sequence<sizeof...(Args)>());
|
|
}
|
|
template<class T, class... Args>
|
|
template<std::size_t... Is>
|
|
constexpr auto deferred<T,Args...>::get_value_(std::index_sequence<Is...>) -> value_type{
|
|
return T{std::forward<std::tuple_element_t<Is,decltype(m_args)>>(std::get<Is>(m_args))...};
|
|
}
|
|
|
|
template<class Fn, class... Args>
|
|
template<class F, class... FArgs>
|
|
constexpr deferred_function<Fn,Args...>::deferred_function(F&& f, FArgs&&... args):
|
|
m_fn(std::forward<F>(f)),
|
|
m_args{std::forward<FArgs>(args)...}{}
|
|
|
|
template<class Fn, class... Args>
|
|
constexpr decltype(auto) deferred_function<Fn,Args...>::operator()(void){
|
|
return get_value_(std::make_index_sequence<sizeof...(Args)>());
|
|
}
|
|
|
|
template<class Fn, class... Args>
|
|
constexpr decltype(auto) deferred_function<Fn,Args...>::value(void){
|
|
return get_value_(std::make_index_sequence<sizeof...(Args)>());
|
|
}
|
|
template<class Fn, class... Args>
|
|
constexpr deferred_function<Fn,Args...>::operator ret_t(void){
|
|
return get_value_(std::make_index_sequence<sizeof...(Args)>());
|
|
}
|
|
template<class Fn, class... Args>
|
|
template<std::size_t... Is>
|
|
constexpr decltype(auto) deferred_function<Fn,Args...>::get_value_(std::index_sequence<Is...>){
|
|
return std::forward<Fn>(m_fn)(std::forward<std::tuple_element_t<Is,decltype(m_args)>>(std::get<Is>(m_args))...);
|
|
}
|
|
|
|
template<class Fn, class... Args>
|
|
deferred_function(Fn&&, Args&&...) -> deferred_function<Fn&&, Args&&...>;
|
|
|
|
|
|
template<class T, class... Args>
|
|
deferred<T,Args...> make_deferred(Args&&... args){
|
|
return deferred<T,Args...>(std::forward<Args>(args)...);
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|