// -- Boost Lambda Library - actions.hpp ---------------------------------- // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) // // Distributed under 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 www.boost.org // ---------------------------------------------------------------- #ifndef BOOST_LAMBDA_ACTIONS_HPP #define BOOST_LAMBDA_ACTIONS_HPP namespace boost { namespace lambda { template<int Arity, class Act> class action; // these need to be defined here, since the corresponding lambda // functions are members of lambda_functor classes class assignment_action {}; class subscript_action {}; template <class Action> class other_action; // action for specifying the explicit return type template <class RET> class explicit_return_type_action {}; // action for preventing the expansion of a lambda expression struct protect_action {}; // must be defined here, comma is a special case struct comma_action {}; // actions, for which the existence of protect is checked in return type // deduction. template <class Action> struct is_protectable { BOOST_STATIC_CONSTANT(bool, value = false); }; // NOTE: comma action is protectable. Other protectable actions // are listed in operator_actions.hpp template<> struct is_protectable<other_action<comma_action> > { BOOST_STATIC_CONSTANT(bool, value = true); }; namespace detail { // this type is used in return type deductions to signal that deduction // did not find a result. It does not necessarily mean an error, it commonly // means that something else should be tried. class unspecified {}; } // function action is a special case: bind functions can be called with // the return type specialized explicitly e.g. bind<int>(foo); // If this call syntax is used, the return type is stored in the latter // argument of function_action template. Otherwise the argument gets the type // 'unspecified'. // This argument is only relevant in the return type deduction code template <int I, class Result_type = detail::unspecified> class function_action {}; template<class T> class function_action<1, T> { public: template<class RET, class A1> static RET apply(A1& a1) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1); } }; template<class T> class function_action<2, T> { public: template<class RET, class A1, class A2> static RET apply(A1& a1, A2& a2) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2); } }; template<class T> class function_action<3, T> { public: template<class RET, class A1, class A2, class A3> static RET apply(A1& a1, A2& a2, A3& a3) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3); } }; template<class T> class function_action<4, T> { public: template<class RET, class A1, class A2, class A3, class A4> static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3, a4); } }; template<class T> class function_action<5, T> { public: template<class RET, class A1, class A2, class A3, class A4, class A5> static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3, a4, a5); } }; template<class T> class function_action<6, T> { public: template<class RET, class A1, class A2, class A3, class A4, class A5, class A6> static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3, a4, a5, a6); } }; template<class T> class function_action<7, T> { public: template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3, a4, a5, a6, a7); } }; template<class T> class function_action<8, T> { public: template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8); } }; template<class T> class function_action<9, T> { public: template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9); } }; template<class T> class function_action<10, T> { public: template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) { return function_adaptor<typename boost::remove_cv<A1>::type>:: template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); } }; } // namespace lambda } // namespace boost #endif