diff options
Diffstat (limited to '3rdParty/Boost/src/boost/lambda/detail/actions.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/lambda/detail/actions.hpp | 174 |
1 files changed, 174 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/lambda/detail/actions.hpp b/3rdParty/Boost/src/boost/lambda/detail/actions.hpp new file mode 100644 index 0000000..668799f --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/actions.hpp @@ -0,0 +1,174 @@ +// -- 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 |