124 lines
3.9 KiB
C++
124 lines
3.9 KiB
C++
/*
|
|
Helper class used by variadic implementation of variadic boost::signals2::signal.
|
|
|
|
Author: Frank Mori Hess <fmhess@users.sourceforge.net>
|
|
Begin: 2009-05-27
|
|
*/
|
|
// Copyright Frank Mori Hess 2009
|
|
// Use, modification and
|
|
// distribution is subject to the Boost Software License, Version
|
|
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
// For more information, see http://www.boost.org
|
|
|
|
#ifndef BOOST_SIGNALS2_DETAIL_VARIADIC_SLOT_INVOKER_HPP
|
|
#define BOOST_SIGNALS2_DETAIL_VARIADIC_SLOT_INVOKER_HPP
|
|
|
|
#include <boost/signals2/detail/variadic_arg_type.hpp>
|
|
// if compiler has variadic template support, we assume they have
|
|
// a variadic std::tuple implementation here. We don't use boost::tuple
|
|
// because it does not have variadic template support at present.
|
|
#include <tuple>
|
|
|
|
namespace boost
|
|
{
|
|
namespace signals2
|
|
{
|
|
namespace detail
|
|
{
|
|
template<unsigned ... values> class unsigned_meta_array {};
|
|
|
|
template<typename UnsignedMetaArray, unsigned n> class unsigned_meta_array_appender;
|
|
|
|
template<unsigned n, unsigned ... Args>
|
|
class unsigned_meta_array_appender<unsigned_meta_array<Args...>, n>
|
|
{
|
|
public:
|
|
typedef unsigned_meta_array<Args..., n> type;
|
|
};
|
|
|
|
template<unsigned n> class make_unsigned_meta_array;
|
|
|
|
template<> class make_unsigned_meta_array<0>
|
|
{
|
|
public:
|
|
typedef unsigned_meta_array<> type;
|
|
};
|
|
|
|
template<> class make_unsigned_meta_array<1>
|
|
{
|
|
public:
|
|
typedef unsigned_meta_array<0> type;
|
|
};
|
|
|
|
template<unsigned n> class make_unsigned_meta_array
|
|
{
|
|
public:
|
|
typedef typename unsigned_meta_array_appender<typename make_unsigned_meta_array<n-1>::type, n - 1>::type type;
|
|
};
|
|
|
|
template<typename R>
|
|
class call_with_tuple_args
|
|
{
|
|
public:
|
|
typedef R result_type;
|
|
|
|
template<typename Func, typename ... Args>
|
|
R operator()(Func &func, std::tuple<Args...> args) const
|
|
{
|
|
typedef typename make_unsigned_meta_array<sizeof...(Args)>::type indices_type;
|
|
typename Func::result_type *resolver = 0;
|
|
return m_invoke(resolver, func, indices_type(), args);
|
|
}
|
|
private:
|
|
template<typename T, typename Func, unsigned ... indices, typename ... Args>
|
|
R m_invoke(T *, Func &func, unsigned_meta_array<indices...>, std::tuple<Args...> args) const
|
|
{
|
|
return func(std::get<indices>(args)...);
|
|
}
|
|
template<typename Func, unsigned ... indices, typename ... Args>
|
|
R m_invoke(void *, Func &func, unsigned_meta_array<indices...>, std::tuple<Args...> args) const
|
|
{
|
|
func(std::get<indices>(args)...);
|
|
return R();
|
|
}
|
|
};
|
|
|
|
template<typename R, typename ... Args>
|
|
class variadic_slot_invoker
|
|
{
|
|
public:
|
|
typedef R result_type;
|
|
|
|
variadic_slot_invoker(Args & ... args): _args(args...)
|
|
{}
|
|
template<typename ConnectionBodyType>
|
|
result_type operator ()(const ConnectionBodyType &connectionBody) const
|
|
{
|
|
result_type *resolver = 0;
|
|
return m_invoke(connectionBody,
|
|
resolver);
|
|
}
|
|
private:
|
|
template<typename ConnectionBodyType>
|
|
result_type m_invoke(const ConnectionBodyType &connectionBody,
|
|
const void_type *) const
|
|
{
|
|
return call_with_tuple_args<result_type>()(connectionBody->slot.slot_function(), _args);
|
|
return void_type();
|
|
}
|
|
template<typename ConnectionBodyType>
|
|
result_type m_invoke(const ConnectionBodyType &connectionBody, ...) const
|
|
{
|
|
return call_with_tuple_args<result_type>()(connectionBody->slot.slot_function(), _args);
|
|
}
|
|
std::tuple<Args& ...> _args;
|
|
};
|
|
} // namespace detail
|
|
} // namespace signals2
|
|
} // namespace boost
|
|
|
|
|
|
#endif // BOOST_SIGNALS2_DETAIL_VARIADIC_SLOT_INVOKER_HPP
|