Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/lambda')
21 files changed, 7942 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/lambda/bind.hpp b/3rdParty/Boost/src/boost/lambda/bind.hpp new file mode 100644 index 0000000..0371393 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/bind.hpp @@ -0,0 +1,19 @@ +// -- bind.hpp -- Boost Lambda Library -------------------------------------- + +// Copyright (C) 1999-2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) +// Gary Powell (gwpowell@hotmail.com) +// +// 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 http://www.boost.org + +#ifndef BOOST_LAMBDA_BIND_HPP +#define BOOST_LAMBDA_BIND_HPP + +#include "boost/lambda/core.hpp" + +#include "boost/lambda/detail/bind_functions.hpp" + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/core.hpp b/3rdParty/Boost/src/boost/lambda/core.hpp new file mode 100644 index 0000000..e42766f --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/core.hpp @@ -0,0 +1,79 @@ +// -- core.hpp -- Boost Lambda Library ------------------------------------- +// +// Copyright (C) 2000 Gary Powell (powellg@amazon.com) +// 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 +// +// Includes the core of LL, without any real features for client: +// +// tuples, lambda functors, return type deduction templates, +// argument substitution mechanism (select functions) +// +// Some functionality comes as well: +// Assignment and subscript operators, as well as function +// call operator for placeholder variables. +// ------------------------------------------------------------------------- + +#ifndef BOOST_LAMBDA_CORE_HPP +#define BOOST_LAMBDA_CORE_HPP + +#include "boost/type_traits/transform_traits.hpp" +#include "boost/type_traits/cv_traits.hpp" + +#include "boost/tuple/tuple.hpp" + +// inject some of the tuple names into lambda +namespace boost { +namespace lambda { + +using ::boost::tuples::tuple; +using ::boost::tuples::null_type; + +} // lambda +} // boost + +#include "boost/lambda/detail/lambda_config.hpp" +#include "boost/lambda/detail/lambda_fwd.hpp" + +#include "boost/lambda/detail/arity_code.hpp" +#include "boost/lambda/detail/actions.hpp" + +#include "boost/lambda/detail/lambda_traits.hpp" + +#include "boost/lambda/detail/function_adaptors.hpp" +#include "boost/lambda/detail/return_type_traits.hpp" + +#include "boost/lambda/detail/select_functions.hpp" + +#include "boost/lambda/detail/lambda_functor_base.hpp" + +#include "boost/lambda/detail/lambda_functors.hpp" + +#include "boost/lambda/detail/ret.hpp" + +namespace boost { +namespace lambda { + +namespace { + + // These are constants types and need to be initialised + boost::lambda::placeholder1_type free1 = boost::lambda::placeholder1_type(); + boost::lambda::placeholder2_type free2 = boost::lambda::placeholder2_type(); + boost::lambda::placeholder3_type free3 = boost::lambda::placeholder3_type(); + + boost::lambda::placeholder1_type& _1 = free1; + boost::lambda::placeholder2_type& _2 = free2; + boost::lambda::placeholder3_type& _3 = free3; + // _1, _2, ... naming scheme by Peter Dimov +} // unnamed + +} // lambda +} // boost + + +#endif //BOOST_LAMBDA_CORE_HPP 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 diff --git a/3rdParty/Boost/src/boost/lambda/detail/arity_code.hpp b/3rdParty/Boost/src/boost/lambda/detail/arity_code.hpp new file mode 100644 index 0000000..bed34b9 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/arity_code.hpp @@ -0,0 +1,110 @@ +// -- Boost Lambda Library ------------------------------------------------- + +// 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_ARITY_CODE_HPP +#define BOOST_LAMBDA_ARITY_CODE_HPP + +#include "boost/type_traits/cv_traits.hpp" +#include "boost/type_traits/transform_traits.hpp" + +namespace boost { +namespace lambda { + +// These constants state, whether a lambda_functor instantiation results from +// an expression which contains no placeholders (NONE), +// only free1 placeholders (FIRST), +// free2 placeholders and maybe free1 placeholders (SECOND), +// free3 and maybe free1 and free2 placeholders (THIRD), +// freeE placeholders and maybe free1 and free2 (EXCEPTION). +// RETHROW means, that a rethrow expression is used somewhere in the lambda_functor. + +enum { NONE = 0x00, // Notice we are using bits as flags here. + FIRST = 0x01, + SECOND = 0x02, + THIRD = 0x04, + EXCEPTION = 0x08, + RETHROW = 0x10}; + + +template<class T> +struct get_tuple_arity; + +namespace detail { + +template <class T> struct get_arity_; + +} // end detail; + +template <class T> struct get_arity { + + BOOST_STATIC_CONSTANT(int, value = detail::get_arity_<typename boost::remove_cv<typename boost::remove_reference<T>::type>::type>::value); + +}; + +namespace detail { + +template<class T> +struct get_arity_ { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + +template<class T> +struct get_arity_<lambda_functor<T> > { + BOOST_STATIC_CONSTANT(int, value = get_arity<T>::value); +}; + +template<class Action, class Args> +struct get_arity_<lambda_functor_base<Action, Args> > { + BOOST_STATIC_CONSTANT(int, value = get_tuple_arity<Args>::value); +}; + +template<int I> +struct get_arity_<placeholder<I> > { + BOOST_STATIC_CONSTANT(int, value = I); +}; + +} // detail + +template<class T> +struct get_tuple_arity { + BOOST_STATIC_CONSTANT(int, value = get_arity<typename T::head_type>::value | get_tuple_arity<typename T::tail_type>::value); +}; + + +template<> +struct get_tuple_arity<null_type> { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + + + // Does T have placeholder<I> as it's subexpression? + +template<class T, int I> +struct has_placeholder { + BOOST_STATIC_CONSTANT(bool, value = (get_arity<T>::value & I) != 0); +}; + +template<int I, int J> +struct includes_placeholder { + BOOST_STATIC_CONSTANT(bool, value = (J & I) != 0); +}; + +template<int I, int J> +struct lacks_placeholder { + BOOST_STATIC_CONSTANT(bool, value = ((J & I) == 0)); +}; + + +} // namespace lambda +} // namespace boost + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/detail/bind_functions.hpp b/3rdParty/Boost/src/boost/lambda/detail/bind_functions.hpp new file mode 100644 index 0000000..f85513c --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/bind_functions.hpp @@ -0,0 +1,1879 @@ +// -- bind_functions.hpp -- Boost Lambda Library +// +// 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 http://www.boost.org + +// ---------------------------------------------------------------- + +#ifndef BOOST_LAMBDA_BIND_FUNCTIONS_HPP +#define BOOST_LAMBDA_BIND_FUNCTIONS_HPP + + +namespace boost { +namespace lambda { + +#ifdef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING + + // gcc 2.96 instantiates bind functions it does not even call. + // These instantiations lead to incorrect types in the return type, + // and a compilation error results. + // This tweaking is to prevent the formation of the erroneous type. +namespace detail { + +template<class T> struct constify_non_funcs { + typedef typename + detail::IF_type<boost::is_function<T>::value, + boost::add_reference<T>, + boost::add_const<T> + >::type type; +}; + +} +#endif +// 1-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result> +inline const +lambda_functor< + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper<Result(&)()>::type + > +> + +bind(Result(& a1)()) { + return + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper<Result(&)()>::type + > + ( typename detail::bind_tuple_mapper<Result(&)()>::type + (a1) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1> +inline const +lambda_functor< + lambda_functor_base< + action<1, function_action<1> >, + typename detail::bind_tuple_mapper<const Arg1>::type + > +> + +bind(const Arg1& a1) { + return + lambda_functor_base< + action<1, function_action<1> >, + typename detail::bind_tuple_mapper<const Arg1>::type + > + ( typename detail::bind_tuple_mapper<const Arg1>::type + (a1) + ); +} + +template <class Result, class Arg1> +inline const +lambda_functor< + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper<const Arg1>::type + > +> + +bind(const Arg1& a1) { + return + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper<const Arg1>::type + > + ( typename detail::bind_tuple_mapper<const Arg1>::type + (a1) + ); +} + + + #else +template <class Arg1> +inline const +lambda_functor< + lambda_functor_base< + action<1, function_action<1> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type + >::type + > +> + +bind(const Arg1& a1) { + return + lambda_functor_base< + action<1, function_action<1> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type + >::type + (a1) + ); +} + +template <class Result, class Arg1> +inline const +lambda_functor< + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type + >::type + > +> + +bind(const Arg1& a1) { + return + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type + >::type + (a1) + ); +} + +template <class Result> +inline const +lambda_functor< + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper<Result(*)()>::type + > +> + +bind(Result(* const & a1)()) { + return + lambda_functor_base< + action<1, function_action<1, Result> >, + typename detail::bind_tuple_mapper<Result(*)()>::type + > + ( typename detail::bind_tuple_mapper<Result(*)()>::type + (a1) + ); +} + + +#endif + +// 2-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type + > +> + +bind(Result(&a1)(Par1), const Arg2& a2) { + return + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type + > + ( typename detail::bind_tuple_mapper<Result(&)(Par1), const Arg2>::type + (a1, a2) + ); +} +#endif + +#ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, function_action<2> >, + typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type + > +> + +bind(const Arg1& a1, const Arg2& a2) { + return + lambda_functor_base< + action<2, function_action<2> >, + typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type + > + ( typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type + (a1, a2) + ); +} + +template <class Result, class Arg1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type + > +> + +bind(const Arg1& a1, const Arg2& a2) { + return + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type + > + ( typename detail::bind_tuple_mapper<const Arg1, const Arg2>::type + (a1, a2) + ); +} + + + #else +template <class Arg1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, function_action<2> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2) { + return + lambda_functor_base< + action<2, function_action<2> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2 + >::type + (a1, a2) + ); +} + +template <class Result, class Arg1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2) { + return + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2 + >::type + (a1, a2) + ); +} + +template <class Result, class Par1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type + > +> + +bind(Result(* const & a1)(Par1), const Arg2& a2) { + return + lambda_functor_base< + action<2, function_action<2, Result> >, + typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type + > + ( typename detail::bind_tuple_mapper<Result(*)(Par1), const Arg2>::type + (a1, a2) + ); +} + + + #endif + +// 3-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Arg2, class Arg3> +inline const +lambda_functor< + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2), const Arg2, const Arg3 + >::type + > +> + +bind(Result(&a1)(Par1, Par2), const Arg2& a2, const Arg3& a3) { + return + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2), const Arg2, const Arg3 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2), const Arg2, const Arg3 + >::type + (a1, a2, a3) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3> +inline const +lambda_functor< + lambda_functor_base< + action<3, function_action<3> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { + return + lambda_functor_base< + action<3, function_action<3> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3 + >::type + (a1, a2, a3) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3> +inline const +lambda_functor< + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { + return + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3 + >::type + (a1, a2, a3) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3> +inline const +lambda_functor< + lambda_functor_base< + action<3, function_action<3> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { + return + lambda_functor_base< + action<3, function_action<3> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3 + >::type + (a1, a2, a3) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3> +inline const +lambda_functor< + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3) { + return + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3 + >::type + (a1, a2, a3) + ); +} + +template <class Result, class Par1, class Par2, class Arg2, class Arg3> +inline const +lambda_functor< + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2), const Arg2, const Arg3 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2), const Arg2& a2, const Arg3& a3) { + return + lambda_functor_base< + action<3, function_action<3, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2), const Arg2, const Arg3 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2), const Arg2, const Arg3 + >::type + (a1, a2, a3) + ); +} + + + #endif + +// 4-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Par3, class Arg2, + class Arg3, class Arg4> +inline const +lambda_functor< + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 + >::type + > +> + +bind(Result(&a1)(Par1, Par2, Par3), const Arg2& a2, const Arg3& a3, + const Arg4& a4) { + return + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 + >::type + (a1, a2, a3, a4) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3, class Arg4> +inline const +lambda_functor< + lambda_functor_base< + action<4, function_action<4> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { + return + lambda_functor_base< + action<4, function_action<4> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4 + >::type + (a1, a2, a3, a4) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4> +inline const +lambda_functor< + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { + return + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4 + >::type + (a1, a2, a3, a4) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3, class Arg4> +inline const +lambda_functor< + lambda_functor_base< + action<4, function_action<4> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { + return + lambda_functor_base< + action<4, function_action<4> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4 + >::type + (a1, a2, a3, a4) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4> +inline const +lambda_functor< + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4) { + return + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4 + >::type + (a1, a2, a3, a4) + ); +} + +template <class Result, class Par1, class Par2, class Par3, class Arg2, + class Arg3, class Arg4> +inline const +lambda_functor< + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2, Par3), const Arg2& a2, + const Arg3& a3, const Arg4& a4) { + return + lambda_functor_base< + action<4, function_action<4, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3), const Arg2, const Arg3, const Arg4 + >::type + (a1, a2, a3, a4) + ); +} + + + #endif + +// 5-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Arg2, class Arg3, class Arg4, class Arg5> +inline const +lambda_functor< + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, + const Arg5 + >::type + > +> + +bind(Result(&a1)(Par1, Par2, Par3, Par4), const Arg2& a2, const Arg3& a3, + const Arg4& a4, const Arg5& a5) { + return + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, + const Arg5 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, + const Arg5 + >::type + (a1, a2, a3, a4, a5) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +inline const +lambda_functor< + lambda_functor_base< + action<5, function_action<5> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5) { + return + lambda_functor_base< + action<5, function_action<5> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 + >::type + (a1, a2, a3, a4, a5) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5> +inline const +lambda_functor< + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5) { + return + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5 + >::type + (a1, a2, a3, a4, a5) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +inline const +lambda_functor< + lambda_functor_base< + action<5, function_action<5> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5) { + return + lambda_functor_base< + action<5, function_action<5> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5 + >::type + (a1, a2, a3, a4, a5) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5> +inline const +lambda_functor< + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5) { + return + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5 + >::type + (a1, a2, a3, a4, a5) + ); +} + +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Arg2, class Arg3, class Arg4, class Arg5> +inline const +lambda_functor< + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, + const Arg5 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2, Par3, Par4), const Arg2& a2, + const Arg3& a3, const Arg4& a4, const Arg5& a5) { + return + lambda_functor_base< + action<5, function_action<5, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, + const Arg5 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4), const Arg2, const Arg3, const Arg4, + const Arg5 + >::type + (a1, a2, a3, a4, a5) + ); +} + + + #endif + +// 6-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6> +inline const +lambda_functor< + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + > +> + +bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5), const Arg2& a2, + const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6) { + return + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + (a1, a2, a3, a4, a5, a6) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6> +inline const +lambda_functor< + lambda_functor_base< + action<6, function_action<6> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6) { + return + lambda_functor_base< + action<6, function_action<6> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 + >::type + (a1, a2, a3, a4, a5, a6) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6> +inline const +lambda_functor< + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6) { + return + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6 + >::type + (a1, a2, a3, a4, a5, a6) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6> +inline const +lambda_functor< + lambda_functor_base< + action<6, function_action<6> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6) { + return + lambda_functor_base< + action<6, function_action<6> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6 + >::type + (a1, a2, a3, a4, a5, a6) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6> +inline const +lambda_functor< + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6) { + return + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6 + >::type + (a1, a2, a3, a4, a5, a6) + ); +} + +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6> +inline const +lambda_functor< + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5), const Arg2& a2, + const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6) { + return + lambda_functor_base< + action<6, function_action<6, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6 + >::type + (a1, a2, a3, a4, a5, a6) + ); +} + + + #endif + +// 7-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7> +inline const +lambda_functor< + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > +> + +bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2& a2, + const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6, + const Arg7& a7) { + return + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + (a1, a2, a3, a4, a5, a6, a7) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7> +inline const +lambda_functor< + lambda_functor_base< + action<7, function_action<7> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7) { + return + lambda_functor_base< + action<7, function_action<7> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7 + >::type + (a1, a2, a3, a4, a5, a6, a7) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7> +inline const +lambda_functor< + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7) { + return + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7 + >::type + (a1, a2, a3, a4, a5, a6, a7) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7> +inline const +lambda_functor< + lambda_functor_base< + action<7, function_action<7> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7) { + return + lambda_functor_base< + action<7, function_action<7> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 + >::type + (a1, a2, a3, a4, a5, a6, a7) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7> +inline const +lambda_functor< + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7) { + return + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7 + >::type + (a1, a2, a3, a4, a5, a6, a7) + ); +} + +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7> +inline const +lambda_functor< + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6), + const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, + const Arg6& a6, const Arg7& a7) { + return + lambda_functor_base< + action<7, function_action<7, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6), const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7 + >::type + (a1, a2, a3, a4, a5, a6, a7) + ); +} + + + #endif + +// 8-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Par7, class Arg2, class Arg3, + class Arg4, class Arg5, class Arg6, class Arg7, class Arg8> +inline const +lambda_functor< + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > +> + +bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2& a2, + const Arg3& a3, const Arg4& a4, const Arg5& a5, const Arg6& a6, + const Arg7& a7, const Arg8& a8) { + return + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7, class Arg8> +inline const +lambda_functor< + lambda_functor_base< + action<8, function_action<8> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { + return + lambda_functor_base< + action<8, function_action<8> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7, class Arg8> +inline const +lambda_functor< + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { + return + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7, class Arg8> +inline const +lambda_functor< + lambda_functor_base< + action<8, function_action<8> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { + return + lambda_functor_base< + action<8, function_action<8> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7, class Arg8> +inline const +lambda_functor< + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8) { + return + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8) + ); +} + +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Par7, class Arg2, class Arg3, + class Arg4, class Arg5, class Arg6, class Arg7, class Arg8> +inline const +lambda_functor< + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), + const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, + const Arg6& a6, const Arg7& a7, const Arg8& a8) { + return + lambda_functor_base< + action<8, function_action<8, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8) + ); +} + + + #endif + +// 9-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Par7, class Par8, class Arg2, + class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, + class Arg8, class Arg9> +inline const +lambda_functor< + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, + const Arg9 + >::type + > +> + +bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), + const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, + const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9) { + return + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7, class Arg8, class Arg9> +inline const +lambda_functor< + lambda_functor_base< + action<9, function_action<9> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9) { + return + lambda_functor_base< + action<9, function_action<9> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7, class Arg8, class Arg9> +inline const +lambda_functor< + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9) { + return + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7, class Arg8, class Arg9> +inline const +lambda_functor< + lambda_functor_base< + action<9, function_action<9> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9) { + return + lambda_functor_base< + action<9, function_action<9> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7, class Arg8, class Arg9> +inline const +lambda_functor< + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9) { + return + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9) + ); +} + +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Par7, class Par8, class Arg2, + class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, + class Arg8, class Arg9> +inline const +lambda_functor< + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, + const Arg9 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), + const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, + const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9) { + return + lambda_functor_base< + action<9, function_action<9, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8), const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9) + ); +} + + + #endif + +// 10-argument bind functions -------------------------- +#ifndef BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Par7, class Par8, class Par9, + class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, + class Arg7, class Arg8, class Arg9, class Arg10> +inline const +lambda_functor< + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), + const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9, const Arg10 + >::type + > +> + +bind(Result(&a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), + const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, + const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9, + const Arg10& a10) { + return + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), + const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9, const Arg10 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(&)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), + const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9, const Arg10 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) + ); +} +#endif + + #ifndef BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7, class Arg8, class Arg9, class Arg10> +inline const +lambda_functor< + lambda_functor_base< + action<10, function_action<10> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9, const Arg10 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9, const Arg10& a10) { + return + lambda_functor_base< + action<10, function_action<10> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, + class Arg10> +inline const +lambda_functor< + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9, const Arg10 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9, const Arg10& a10) { + return + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 + >::type + > + ( typename detail::bind_tuple_mapper< + const Arg1, const Arg2, const Arg3, const Arg4, const Arg5, + const Arg6, const Arg7, const Arg8, const Arg9, const Arg10 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) + ); +} + + + #else +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, + class Arg6, class Arg7, class Arg8, class Arg9, class Arg10> +inline const +lambda_functor< + lambda_functor_base< + action<10, function_action<10> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9, + const Arg10 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9, const Arg10& a10) { + return + lambda_functor_base< + action<10, function_action<10> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9, const Arg10 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9, const Arg10 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) + ); +} + +template <class Result, class Arg1, class Arg2, class Arg3, class Arg4, + class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, + class Arg10> +inline const +lambda_functor< + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, const Arg3, + const Arg4, const Arg5, const Arg6, const Arg7, const Arg8, const Arg9, + const Arg10 + >::type + > +> + +bind(const Arg1& a1, const Arg2& a2, const Arg3& a3, const Arg4& a4, + const Arg5& a5, const Arg6& a6, const Arg7& a7, const Arg8& a8, + const Arg9& a9, const Arg10& a10) { + return + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9, const Arg10 + >::type + > + ( typename detail::bind_tuple_mapper< + typename detail::constify_non_funcs<Arg1>::type, const Arg2, + const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9, const Arg10 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) + ); +} + +template <class Result, class Par1, class Par2, class Par3, class Par4, + class Par5, class Par6, class Par7, class Par8, class Par9, + class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, + class Arg7, class Arg8, class Arg9, class Arg10> +inline const +lambda_functor< + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), + const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, const Arg7, + const Arg8, const Arg9, const Arg10 + >::type + > +> + +bind(Result(* const & a1)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, + Par9), const Arg2& a2, const Arg3& a3, const Arg4& a4, const Arg5& a5, + const Arg6& a6, const Arg7& a7, const Arg8& a8, const Arg9& a9, + const Arg10& a10) { + return + lambda_functor_base< + action<10, function_action<10, Result> >, + typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), + const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9, const Arg10 + >::type + > + ( typename detail::bind_tuple_mapper< + Result(*)(Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9), + const Arg2, const Arg3, const Arg4, const Arg5, const Arg6, + const Arg7, const Arg8, const Arg9, const Arg10 + >::type + (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) + ); +} + + + #endif + +} // namespace lambda +} // namespace boost + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp b/3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp new file mode 100644 index 0000000..35db8b4 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/function_adaptors.hpp @@ -0,0 +1,789 @@ +// Boost Lambda Library - function_adaptors.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_FUNCTION_ADAPTORS_HPP +#define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP + +#include "boost/mpl/has_xxx.hpp" +#include "boost/tuple/tuple.hpp" +#include "boost/type_traits/same_traits.hpp" +#include "boost/type_traits/remove_reference.hpp" +#include "boost/type_traits/remove_cv.hpp" +#include "boost/type_traits/add_const.hpp" +#include "boost/type_traits/add_volatile.hpp" +#include "boost/utility/result_of.hpp" + +namespace boost { +namespace lambda { + +namespace detail { + +BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig) + +template<class Tuple> +struct remove_references_from_elements { + typedef typename boost::tuples::cons< + typename boost::remove_reference<typename Tuple::head_type>::type, + typename remove_references_from_elements<typename Tuple::tail_type>::type + > type; +}; + +template<> +struct remove_references_from_elements<boost::tuples::null_type> { + typedef boost::tuples::null_type type; +}; + +} + +template <class Func> struct function_adaptor { + + typedef typename detail::remove_reference_and_cv<Func>::type plainF; + +#if !defined(BOOST_NO_RESULT_OF) + // Support functors that use the boost::result_of return type convention. + template<class Tuple, int Length, bool HasSig> + struct result_converter; + template<class Tuple, int Length> + struct result_converter<Tuple, Length, true> + : plainF::template sig< + typename detail::remove_references_from_elements<Tuple>::type + > + {}; + template<class Tuple> + struct result_converter<Tuple, 0, false> + : result_of<plainF()> + {}; + template<class Tuple> + struct result_converter<Tuple, 1, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 2, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 3, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type, + typename tuples::element<3, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 4, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type, + typename tuples::element<3, Tuple>::type, + typename tuples::element<4, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 5, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type, + typename tuples::element<3, Tuple>::type, + typename tuples::element<4, Tuple>::type, + typename tuples::element<5, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 6, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type, + typename tuples::element<3, Tuple>::type, + typename tuples::element<4, Tuple>::type, + typename tuples::element<5, Tuple>::type, + typename tuples::element<6, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 7, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type, + typename tuples::element<3, Tuple>::type, + typename tuples::element<4, Tuple>::type, + typename tuples::element<5, Tuple>::type, + typename tuples::element<6, Tuple>::type, + typename tuples::element<7, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 8, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type, + typename tuples::element<3, Tuple>::type, + typename tuples::element<4, Tuple>::type, + typename tuples::element<5, Tuple>::type, + typename tuples::element<6, Tuple>::type, + typename tuples::element<7, Tuple>::type, + typename tuples::element<8, Tuple>::type) + > + {}; + template<class Tuple> + struct result_converter<Tuple, 9, false> + : result_of<plainF( + typename tuples::element<1, Tuple>::type, + typename tuples::element<2, Tuple>::type, + typename tuples::element<3, Tuple>::type, + typename tuples::element<4, Tuple>::type, + typename tuples::element<5, Tuple>::type, + typename tuples::element<6, Tuple>::type, + typename tuples::element<7, Tuple>::type, + typename tuples::element<8, Tuple>::type, + typename tuples::element<9, Tuple>::type) + > + {}; + + // we do not know the return type off-hand, we must ask it from Func + // To sig we pass a cons list, where the head is the function object type + // itself (potentially cv-qualified) + // and the tail contains the types of the actual arguments to be passed + // to the function object. The arguments can be cv qualified + // as well. + template <class Args> + struct sig + : result_converter< + Args + , tuples::length<typename Args::tail_type>::value + , detail::has_sig<plainF>::value + > + {}; +#else // BOOST_NO_RESULT_OF + + template <class Args> class sig { + typedef typename detail::remove_reference_and_cv<Func>::type plainF; + public: + typedef typename plainF::template sig< + typename detail::remove_references_from_elements<Args>::type + >::type type; + }; +#endif + + template<class RET, class A1> + static RET apply(A1& a1) { + return a1(); + } + template<class RET, class A1, class A2> + static RET apply(A1& a1, A2& a2) { + return a1(a2); + } + template<class RET, class A1, class A2, class A3> + static RET apply(A1& a1, A2& a2, A3& a3) { + return a1(a2, a3); + } + template<class RET, class A1, class A2, class A3, class A4> + static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) { + return a1(a2, a3, a4); + } + 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 a1(a2, a3, a4, a5); + } + 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 a1(a2, a3, a4, a5, a6); + } + 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 a1(a2, a3, a4, a5, a6, a7); + } + 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 a1(a2, a3, a4, a5, a6, a7, a8); + } + 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 a1(a2, a3, a4, a5, a6, a7, a8, a9); + } + 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 a1(a2, a3, a4, a5, a6, a7, a8, a9, a10); + } +}; + +template <class Func> struct function_adaptor<const Func>; // error + +// -- function adaptors with data member access +template <class Object, class T> +struct function_adaptor<T Object::*> { + + // typedef detail::unspecified type; + + // T can have qualifiers and can be a reference type + // We get the return type by adding const, if the object through which + // the data member is accessed is const, and finally adding a reference + template<class Args> class sig { + typedef typename boost::tuples::element<1, Args>::type argument_type; + typedef typename boost::remove_reference< + argument_type + >::type unref_type; + + typedef typename detail::IF<boost::is_const<unref_type>::value, + typename boost::add_const<T>::type, + T + >::RET properly_consted_return_type; + + typedef typename detail::IF<boost::is_volatile<unref_type>::value, + typename boost::add_volatile<properly_consted_return_type>::type, + properly_consted_return_type + >::RET properly_cvd_return_type; + + + public: + typedef typename detail::IF<boost::is_reference<argument_type>::value, + typename boost::add_reference<properly_cvd_return_type>::type, + typename boost::remove_cv<T>::type + >::RET type; + }; + + template <class RET> + static RET apply( T Object::*data, Object& o) { + return o.*data; + } + template <class RET> + static RET apply( T Object::*data, const Object& o) { + return o.*data; + } + template <class RET> + static RET apply( T Object::*data, volatile Object& o) { + return o.*data; + } + template <class RET> + static RET apply( T Object::*data, const volatile Object& o) { + return o.*data; + } + template <class RET> + static RET apply( T Object::*data, Object* o) { + return o->*data; + } + template <class RET> + static RET apply( T Object::*data, const Object* o) { + return o->*data; + } + template <class RET> + static RET apply( T Object::*data, volatile Object* o) { + return o->*data; + } + template <class RET> + static RET apply( T Object::*data, const volatile Object* o) { + return o->*data; + } +}; + +// -- function adaptors with 1 argument apply + +template <class Result> +struct function_adaptor<Result (void)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET> + static Result apply(Result (*func)()) { + return func(); + } +}; + +template <class Result> +struct function_adaptor<Result (*)(void)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET> + static Result apply(Result (*func)()) { + return func(); + } +}; + + +// -- function adaptors with 2 argument apply +template <class Object, class Result> +struct function_adaptor<Result (Object::*)() const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET> + static Result apply( Result (Object::*func)() const, const Object* o) { + return (o->*func)(); + } + template <class RET> + static Result apply( Result (Object::*func)() const, const Object& o) { + return (o.*func)(); + } +}; + +template <class Object, class Result> +struct function_adaptor<Result (Object::*)()> { + + template<class T> struct sig { typedef Result type; }; + template <class RET> + static Result apply( Result (Object::*func)(), Object* o) { + return (o->*func)(); + } + template <class RET> + static Result apply( Result (Object::*func)(), Object& o) { + return (o.*func)(); + } +}; + +template <class Arg1, class Result> +struct function_adaptor<Result (Arg1)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1> + static Result apply(Result (*func)(Arg1), A1& a1) { + return func(a1); + } +}; + +template <class Arg1, class Result> +struct function_adaptor<Result (*)(Arg1)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1> + static Result apply(Result (*func)(Arg1), A1& a1) { + return func(a1); + } +}; + + +// -- function adaptors with 3 argument apply +template <class Object, class Arg1, class Result> +struct function_adaptor<Result (Object::*)(Arg1) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1> + static Result apply( Result (Object::*func)(Arg1) const, const Object* o, + A1& a1) { + return (o->*func)(a1); + } + template <class RET, class A1> + static Result apply( Result (Object::*func)(Arg1) const, const Object& o, + A1& a1) { + return (o.*func)(a1); + } +}; + +template <class Object, class Arg1, class Result> +struct function_adaptor<Result (Object::*)(Arg1)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1> + static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) { + return (o->*func)(a1); + } + template <class RET, class A1> + static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) { + return (o.*func)(a1); + } +}; + +template <class Arg1, class Arg2, class Result> +struct function_adaptor<Result (Arg1, Arg2)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2> + static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) { + return func(a1, a2); + } +}; + +template <class Arg1, class Arg2, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2> + static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) { + return func(a1, a2); + } +}; + + +// -- function adaptors with 4 argument apply +template <class Object, class Arg1, class Arg2, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2> + static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) { + return (o->*func)(a1, a2); + } + template <class RET, class A1, class A2> + static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) { + return (o.*func)(a1, a2); + } +}; + +template <class Object, class Arg1, class Arg2, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2> + static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) { + return (o->*func)(a1, a2); + } + template <class RET, class A1, class A2> + static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) { + return (o.*func)(a1, a2); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Result> +struct function_adaptor<Result (Arg1, Arg2, Arg3)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3> + static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) { + return func(a1, a2, a3); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3> + static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) { + return func(a1, a2, a3); + } +}; + + +// -- function adaptors with 5 argument apply +template <class Object, class Arg1, class Arg2, class Arg3, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) { + return (o->*func)(a1, a2, a3); + } + template <class RET, class A1, class A2, class A3> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) { + return (o.*func)(a1, a2, a3); + } +}; + +template <class Object, class Arg1, class Arg2, class Arg3, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) { + return (o->*func)(a1, a2, a3); + } + template <class RET, class A1, class A2, class A3> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) { + return (o.*func)(a1, a2, a3); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Result> +struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) { + return func(a1, a2, a3, a4); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) { + return func(a1, a2, a3, a4); + } +}; + + +// -- function adaptors with 6 argument apply +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) { + return (o->*func)(a1, a2, a3, a4); + } + template <class RET, class A1, class A2, class A3, class A4> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) { + return (o.*func)(a1, a2, a3, a4); + } +}; + +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) { + return (o->*func)(a1, a2, a3, a4); + } + template <class RET, class A1, class A2, class A3, class A4> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) { + return (o.*func)(a1, a2, a3, a4); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> +struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { + return func(a1, a2, a3, a4, a5); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { + return func(a1, a2, a3, a4, a5); + } +}; + + +// -- function adaptors with 7 argument apply +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { + return (o->*func)(a1, a2, a3, a4, a5); + } + template <class RET, class A1, class A2, class A3, class A4, class A5> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { + return (o.*func)(a1, a2, a3, a4, a5); + } +}; + +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { + return (o->*func)(a1, a2, a3, a4, a5); + } + template <class RET, class A1, class A2, class A3, class A4, class A5> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { + return (o.*func)(a1, a2, a3, a4, a5); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> +struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { + return func(a1, a2, a3, a4, a5, a6); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { + return func(a1, a2, a3, a4, a5, a6); + } +}; + + +// -- function adaptors with 8 argument apply +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { + return (o->*func)(a1, a2, a3, a4, a5, a6); + } + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { + return (o.*func)(a1, a2, a3, a4, a5, a6); + } +}; + +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { + return (o->*func)(a1, a2, a3, a4, a5, a6); + } + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { + return (o.*func)(a1, a2, a3, a4, a5, a6); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> +struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { + return func(a1, a2, a3, a4, a5, a6, a7); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { + return func(a1, a2, a3, a4, a5, a6, a7); + } +}; + + +// -- function adaptors with 9 argument apply +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { + return (o->*func)(a1, a2, a3, a4, a5, a6, a7); + } + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { + return (o.*func)(a1, a2, a3, a4, a5, a6, a7); + } +}; + +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { + return (o->*func)(a1, a2, a3, a4, a5, a6, a7); + } + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { + return (o.*func)(a1, a2, a3, a4, a5, a6, a7); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> +struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { + return func(a1, a2, a3, a4, a5, a6, a7, a8); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { + return func(a1, a2, a3, a4, a5, a6, a7, a8); + } +}; + + +// -- function adaptors with 10 argument apply +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { + return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8); + } + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { + return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8); + } +}; + +template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> +struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { + return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8); + } + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> + static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { + return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result> +struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) { + return func(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } +}; + +template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result> +struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> { + + template<class T> struct sig { typedef Result type; }; + template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> + static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) { + return func(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } +}; + +} // namespace lambda +} // namespace boost + +#endif + + + + + + + + + + + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/is_instance_of.hpp b/3rdParty/Boost/src/boost/lambda/detail/is_instance_of.hpp new file mode 100644 index 0000000..1dfbd43 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/is_instance_of.hpp @@ -0,0 +1,104 @@ +// Boost Lambda Library - is_instance_of.hpp --------------------- + +// Copyright (C) 2001 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_IS_INSTANCE_OF +#define BOOST_LAMBDA_IS_INSTANCE_OF + +#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT +#include "boost/type_traits/conversion_traits.hpp" // for is_convertible +#include "boost/preprocessor/enum_shifted_params.hpp" +#include "boost/preprocessor/repeat_2nd.hpp" + +// is_instance_of -------------------------------- +// +// is_instance_of_n<A, B>::value is true, if type A is +// an instantiation of a template B, or A derives from an instantiation +// of template B +// +// n is the number of template arguments for B +// +// Example: +// is_instance_of_2<std::istream, basic_stream>::value == true + +// The original implementation was somewhat different, with different versions +// for different compilers. However, there was still a problem +// with gcc.3.0.2 and 3.0.3 compilers, which didn't think regard +// is_instance_of_N<...>::value was a constant. +// John Maddock suggested the way around this problem by building +// is_instance_of templates using boost::is_convertible. +// Now we only have one version of is_instance_of templates, which delagate +// all the nasty compiler tricks to is_convertible. + +#define BOOST_LAMBDA_CLASS(z, N,A) BOOST_PP_COMMA_IF(N) class +#define BOOST_LAMBDA_CLASS_ARG(z, N,A) BOOST_PP_COMMA_IF(N) class A##N +#define BOOST_LAMBDA_ARG(z, N,A) BOOST_PP_COMMA_IF(N) A##N + +#define BOOST_LAMBDA_CLASS_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS, NAME) + +#define BOOST_LAMBDA_CLASS_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS_ARG, NAME) + +#define BOOST_LAMBDA_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_ARG, NAME) + +namespace boost { +namespace lambda { + +#define BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE(INDEX) \ + \ +namespace detail { \ + \ +template <template<BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class F> \ +struct BOOST_PP_CAT(conversion_tester_,INDEX) { \ + template<BOOST_LAMBDA_CLASS_ARG_LIST(INDEX,A)> \ + BOOST_PP_CAT(conversion_tester_,INDEX) \ + (const F<BOOST_LAMBDA_ARG_LIST(INDEX,A)>&); \ +}; \ + \ +} /* end detail */ \ + \ +template <class From, template <BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class To> \ +struct BOOST_PP_CAT(is_instance_of_,INDEX) \ +{ \ + private: \ + typedef ::boost::is_convertible< \ + From, \ + BOOST_PP_CAT(detail::conversion_tester_,INDEX)<To> \ + > helper_type; \ + \ +public: \ + BOOST_STATIC_CONSTANT(bool, value = helper_type::value); \ +}; + + +#define BOOST_LAMBDA_HELPER(z, N, A) BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( BOOST_PP_INC(N) ) + +// Generate the traits for 1-4 argument templates + +BOOST_PP_REPEAT_2ND(4,BOOST_LAMBDA_HELPER,FOO) + +#undef BOOST_LAMBDA_HELPER +#undef BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE +#undef BOOST_LAMBDA_CLASS +#undef BOOST_LAMBDA_ARG +#undef BOOST_LAMBDA_CLASS_ARG +#undef BOOST_LAMBDA_CLASS_LIST +#undef BOOST_LAMBDA_ARG_LIST +#undef BOOST_LAMBDA_CLASS_ARG_LIST + +} // lambda +} // boost + +#endif + + + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/lambda_config.hpp b/3rdParty/Boost/src/boost/lambda/detail/lambda_config.hpp new file mode 100644 index 0000000..9fd1a7b --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/lambda_config.hpp @@ -0,0 +1,48 @@ +// Boost Lambda Library - lambda_config.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_LAMBDA_CONFIG_HPP +#define BOOST_LAMBDA_LAMBDA_CONFIG_HPP + +// add to boost/config.hpp +// for now + + +# if defined __GNUC__ +# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# define BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T +# define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +# endif +# if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) +# define BOOST_NO_TEMPLATED_STREAMS +# define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING +# endif +# if (__GNUC__ == 2 && __GNUC_MINOR__ <= 95) +# define BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER +# endif +# endif // __GNUC__ + + +#if defined __KCC + +#define BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS + +#endif // __KCC + +#endif + + + + + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/lambda_functor_base.hpp b/3rdParty/Boost/src/boost/lambda/detail/lambda_functor_base.hpp new file mode 100644 index 0000000..b084acd --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/lambda_functor_base.hpp @@ -0,0 +1,615 @@ +// Boost Lambda Library lambda_functor_base.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_LAMBDA_FUNCTOR_BASE_HPP +#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP + +#include "boost/type_traits/add_reference.hpp" +#include "boost/type_traits/add_const.hpp" +#include "boost/type_traits/remove_const.hpp" +#include "boost/lambda/detail/lambda_fwd.hpp" +#include "boost/lambda/detail/lambda_traits.hpp" + +namespace boost { +namespace lambda { + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(push) +#pragma warning(disable:4512) //assignment operator could not be generated +#endif + + // for return type deductions we wrap bound argument to this class, + // which fulfils the base class contract for lambda_functors +template <class T> +class identity { + + T elem; +public: + + typedef T element_t; + + // take all parameters as const references. Note that non-const references + // stay as they are. + typedef typename boost::add_reference< + typename boost::add_const<T>::type + >::type par_t; + + explicit identity(par_t t) : elem(t) {} + + template <typename SigArgs> + struct sig { typedef typename boost::remove_const<element_t>::type type; }; + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return elem; } +}; + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(pop) +#endif + +template <class T> +inline lambda_functor<identity<T&> > var(T& t) { return identity<T&>(t); } + + // for lambda functors, var is an identity operator. It was forbidden + // at some point, but we might want to var something that can be a + // non-lambda functor or a lambda functor. +template <class T> +lambda_functor<T> var(const lambda_functor<T>& t) { return t; } + +template <class T> struct var_type { + typedef lambda_functor<identity<T&> > type; +}; + + +template <class T> +inline +lambda_functor<identity<typename bound_argument_conversion<const T>::type> > +constant(const T& t) { + return identity<typename bound_argument_conversion<const T>::type>(t); +} +template <class T> +lambda_functor<T> constant(const lambda_functor<T>& t) { return t; } + +template <class T> struct constant_type { + typedef + lambda_functor< + identity<typename bound_argument_conversion<const T>::type> + > type; +}; + + + +template <class T> +inline lambda_functor<identity<const T&> > constant_ref(const T& t) { + return identity<const T&>(t); +} +template <class T> +lambda_functor<T> constant_ref(const lambda_functor<T>& t) { return t; } + +template <class T> struct constant_ref_type { + typedef + lambda_functor<identity<const T&> > type; +}; + + + + // as_lambda_functor turns any types to lambda functors + // non-lambda_functors will be bound argument types +template <class T> +struct as_lambda_functor { + typedef typename + detail::remove_reference_and_cv<T>::type plain_T; + typedef typename + detail::IF<is_lambda_functor<plain_T>::value, + plain_T, + lambda_functor< + identity<typename bound_argument_conversion<T>::type> + > + >::RET type; +}; + +// turns arbitrary objects into lambda functors +template <class T> +inline +lambda_functor<identity<typename bound_argument_conversion<const T>::type> > +to_lambda_functor(const T& t) { + return identity<typename bound_argument_conversion<const T>::type>(t); +} + +template <class T> +inline lambda_functor<T> +to_lambda_functor(const lambda_functor<T>& t) { + return t; +} + +namespace detail { + + + +// In a call constify_rvals<T>::go(x) +// x should be of type T. If T is a non-reference type, do +// returns x as const reference. +// Otherwise the type doesn't change. +// The purpose of this class is to avoid +// 'cannot bind temporaries to non-const references' errors. +template <class T> struct constify_rvals { + template<class U> + static inline const U& go(const U& u) { return u; } +}; + +template <class T> struct constify_rvals<T&> { + template<class U> + static inline U& go(U& u) { return u; } +}; + + // check whether one of the elements of a tuple (cons list) is of type + // null_type. Needed, because the compiler goes ahead and instantiates + // sig template for nullary case even if the nullary operator() is not + // called +template <class T> struct is_null_type +{ BOOST_STATIC_CONSTANT(bool, value = false); }; + +template <> struct is_null_type<null_type> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +template<class Tuple> struct has_null_type { + BOOST_STATIC_CONSTANT(bool, value = (is_null_type<typename Tuple::head_type>::value || has_null_type<typename Tuple::tail_type>::value)); +}; +template<> struct has_null_type<null_type> { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + + +// helpers ------------------- + + +template<class Args, class SigArgs> +class deduce_argument_types_ { + typedef typename as_lambda_functor<typename Args::head_type>::type lf_t; + typedef typename lf_t::inherited::template sig<SigArgs>::type el_t; +public: + typedef + boost::tuples::cons< + el_t, + typename deduce_argument_types_<typename Args::tail_type, SigArgs>::type + > type; +}; + +template<class SigArgs> +class deduce_argument_types_<null_type, SigArgs> { +public: + typedef null_type type; +}; + + +// // note that tuples cannot have plain function types as elements. +// // Hence, all other types will be non-const, except references to +// // functions. +// template <class T> struct remove_reference_except_from_functions { +// typedef typename boost::remove_reference<T>::type t; +// typedef typename detail::IF<boost::is_function<t>::value, T, t>::RET type; +// }; + +template<class Args, class SigArgs> +class deduce_non_ref_argument_types_ { + typedef typename as_lambda_functor<typename Args::head_type>::type lf_t; + typedef typename lf_t::inherited::template sig<SigArgs>::type el_t; +public: + typedef + boost::tuples::cons< + // typename detail::remove_reference_except_from_functions<el_t>::type, + typename boost::remove_reference<el_t>::type, + typename deduce_non_ref_argument_types_<typename Args::tail_type, SigArgs>::type + > type; +}; + +template<class SigArgs> +class deduce_non_ref_argument_types_<null_type, SigArgs> { +public: + typedef null_type type; +}; + + // ------------- + +// take stored Args and Open Args, and return a const list with +// deduced elements (real return types) +template<class Args, class SigArgs> +class deduce_argument_types { + typedef typename deduce_argument_types_<Args, SigArgs>::type t1; +public: + typedef typename detail::IF< + has_null_type<t1>::value, null_type, t1 + >::RET type; +}; + +// take stored Args and Open Args, and return a const list with +// deduced elements (references are stripped from the element types) + +template<class Args, class SigArgs> +class deduce_non_ref_argument_types { + typedef typename deduce_non_ref_argument_types_<Args, SigArgs>::type t1; +public: + typedef typename detail::IF< + has_null_type<t1>::value, null_type, t1 + >::RET type; +}; + +template <int N, class Args, class SigArgs> +struct nth_return_type_sig { + typedef typename + as_lambda_functor< + typename boost::tuples::element<N, Args>::type + // typename tuple_element_as_reference<N, Args>::type + >::type lf_type; + + typedef typename lf_type::inherited::template sig<SigArgs>::type type; +}; + +template<int N, class Tuple> struct element_or_null { + typedef typename boost::tuples::element<N, Tuple>::type type; +}; + +template<int N> struct element_or_null<N, null_type> { + typedef null_type type; +}; + + + + +} // end detail + + // -- lambda_functor base --------------------- + +// the explicit_return_type_action case ----------------------------------- +template<class RET, class Args> +class lambda_functor_base<explicit_return_type_action<RET>, Args> +{ +public: + Args args; + + typedef RET result_type; + + explicit lambda_functor_base(const Args& a) : args(a) {} + + template <class SigArgs> struct sig { typedef RET type; }; + + template<class RET_, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const + { + return detail::constify_rvals<RET>::go( + detail::r_select<RET>::go(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)); + } +}; + +// the protect_action case ----------------------------------- +template<class Args> +class lambda_functor_base<protect_action, Args> +{ +public: + Args args; +public: + + explicit lambda_functor_base(const Args& a) : args(a) {} + + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const + { + CALL_USE_ARGS; + return boost::tuples::get<0>(args); + } + + template<class SigArgs> struct sig { + // typedef typename detail::tuple_element_as_reference<0, SigArgs>::type type; + typedef typename boost::tuples::element<0, Args>::type type; + }; +}; + +// Do nothing -------------------------------------------------------- +class do_nothing_action {}; + +template<class Args> +class lambda_functor_base<do_nothing_action, Args> { + // Args args; +public: + // explicit lambda_functor_base(const Args& a) {} + lambda_functor_base() {} + + + template<class RET, CALL_TEMPLATE_ARGS> RET call(CALL_FORMAL_ARGS) const { + return CALL_USE_ARGS; + } + + template<class SigArgs> struct sig { typedef void type; }; +}; + + +// These specializations provide a shorter notation to define actions. +// These lambda_functor_base instances take care of the recursive evaluation +// of the arguments and pass the evaluated arguments to the apply function +// of an action class. To make action X work with these classes, one must +// instantiate the lambda_functor_base as: +// lambda_functor_base<action<ARITY, X>, Args> +// Where ARITY is the arity of the apply function in X + +// The return type is queried as: +// return_type_N<X, EvaluatedArgumentTypes>::type +// for which there must be a specialization. + +// Function actions, casts, throws,... all go via these classes. + + +template<class Act, class Args> +class lambda_functor_base<action<0, Act>, Args> +{ +public: +// Args args; not needed + explicit lambda_functor_base(const Args& /*a*/) {} + + template<class SigArgs> struct sig { + typedef typename return_type_N<Act, null_type>::type type; + }; + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { + CALL_USE_ARGS; + return Act::template apply<RET>(); + } +}; + + +#if defined BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART +#error "Multiple defines of BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART" +#endif + + +#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(ARITY) \ +template<class Act, class Args> \ +class lambda_functor_base<action<ARITY, Act>, Args> \ +{ \ +public: \ + Args args; \ + \ + explicit lambda_functor_base(const Args& a) : args(a) {} \ + \ + template<class SigArgs> struct sig { \ + typedef typename \ + detail::deduce_argument_types<Args, SigArgs>::type rets_t; \ + public: \ + typedef typename \ + return_type_N_prot<Act, rets_t>::type type; \ + }; \ + \ + \ + template<class RET, CALL_TEMPLATE_ARGS> \ + RET call(CALL_FORMAL_ARGS) const { \ + using boost::tuples::get; \ + using detail::constify_rvals; \ + using detail::r_select; \ + using detail::element_or_null; \ + using detail::deduce_argument_types; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(1) + + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(2) + + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(3) + + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(4) + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + typedef typename element_or_null<3, rets_t>::type rt3; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(5) + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + typedef typename element_or_null<3, rets_t>::type rt3; + typedef typename element_or_null<4, rets_t>::type rt4; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(6) + + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + typedef typename element_or_null<3, rets_t>::type rt3; + typedef typename element_or_null<4, rets_t>::type rt4; + typedef typename element_or_null<5, rets_t>::type rt5; + + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(7) + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + typedef typename element_or_null<3, rets_t>::type rt3; + typedef typename element_or_null<4, rets_t>::type rt4; + typedef typename element_or_null<5, rets_t>::type rt5; + typedef typename element_or_null<6, rets_t>::type rt6; + + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(8) + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + typedef typename element_or_null<3, rets_t>::type rt3; + typedef typename element_or_null<4, rets_t>::type rt4; + typedef typename element_or_null<5, rets_t>::type rt5; + typedef typename element_or_null<6, rets_t>::type rt6; + typedef typename element_or_null<7, rets_t>::type rt7; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(9) + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + typedef typename element_or_null<3, rets_t>::type rt3; + typedef typename element_or_null<4, rets_t>::type rt4; + typedef typename element_or_null<5, rets_t>::type rt5; + typedef typename element_or_null<6, rets_t>::type rt6; + typedef typename element_or_null<7, rets_t>::type rt7; + typedef typename element_or_null<8, rets_t>::type rt8; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(10) + typedef typename + deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; + typedef typename element_or_null<0, rets_t>::type rt0; + typedef typename element_or_null<1, rets_t>::type rt1; + typedef typename element_or_null<2, rets_t>::type rt2; + typedef typename element_or_null<3, rets_t>::type rt3; + typedef typename element_or_null<4, rets_t>::type rt4; + typedef typename element_or_null<5, rets_t>::type rt5; + typedef typename element_or_null<6, rets_t>::type rt6; + typedef typename element_or_null<7, rets_t>::type rt7; + typedef typename element_or_null<8, rets_t>::type rt8; + typedef typename element_or_null<9, rets_t>::type rt9; + + return Act::template apply<RET>( + constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS)), + constify_rvals<rt9>::go(r_select<rt9>::go(get<9>(args), CALL_ACTUAL_ARGS)) + ); + } +}; + +#undef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART + + +} // namespace lambda +} // namespace boost + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/detail/lambda_functors.hpp b/3rdParty/Boost/src/boost/lambda/detail/lambda_functors.hpp new file mode 100644 index 0000000..9b1b082 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/lambda_functors.hpp @@ -0,0 +1,324 @@ +// Boost Lambda Library - lambda_functors.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 http://www.boost.org + +// ------------------------------------------------ + +#ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP +#define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + +#include <boost/mpl/or.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_array.hpp> + +#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\ + typename lazy_disable_if<is_array<A1>, typename R1 >::type +#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) \ + typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2> >, typename R1, R2 >::type +#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) \ + typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2>, is_array<A3> >, typename R1, R2, R3 >::type + +#else + +#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type +#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type +#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type + +#endif + +namespace boost { +namespace lambda { + +// -- lambda_functor -------------------------------------------- +// -------------------------------------------------------------- + +//inline const null_type const_null_type() { return null_type(); } + +namespace detail { +namespace { + + static const null_type constant_null_type = null_type(); + +} // unnamed +} // detail + +class unused {}; + +#define cnull_type() detail::constant_null_type + +// -- free variables types -------------------------------------------------- + + // helper to work around the case where the nullary return type deduction + // is always performed, even though the functor is not nullary +namespace detail { + template<int N, class Tuple> struct get_element_or_null_type { + typedef typename + detail::tuple_element_as_reference<N, Tuple>::type type; + }; + template<int N> struct get_element_or_null_type<N, null_type> { + typedef null_type type; + }; +} + +template <int I> struct placeholder; + +template<> struct placeholder<FIRST> { + + template<class SigArgs> struct sig { + typedef typename detail::get_element_or_null_type<0, SigArgs>::type type; + }; + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { + BOOST_STATIC_ASSERT(boost::is_reference<RET>::value); + CALL_USE_ARGS; // does nothing, prevents warnings for unused args + return a; + } +}; + +template<> struct placeholder<SECOND> { + + template<class SigArgs> struct sig { + typedef typename detail::get_element_or_null_type<1, SigArgs>::type type; + }; + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return b; } +}; + +template<> struct placeholder<THIRD> { + + template<class SigArgs> struct sig { + typedef typename detail::get_element_or_null_type<2, SigArgs>::type type; + }; + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return c; } +}; + +template<> struct placeholder<EXCEPTION> { + + template<class SigArgs> struct sig { + typedef typename detail::get_element_or_null_type<3, SigArgs>::type type; + }; + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return env; } +}; + +typedef const lambda_functor<placeholder<FIRST> > placeholder1_type; +typedef const lambda_functor<placeholder<SECOND> > placeholder2_type; +typedef const lambda_functor<placeholder<THIRD> > placeholder3_type; + + +/////////////////////////////////////////////////////////////////////////////// + + +// free variables are lambda_functors. This is to allow uniform handling with +// other lambda_functors. +// ------------------------------------------------------------------- + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(push) +#pragma warning(disable:4512) //assignment operator could not be generated +#endif + +// -- lambda_functor NONE ------------------------------------------------ +template <class T> +class lambda_functor : public T +{ + +BOOST_STATIC_CONSTANT(int, arity_bits = get_arity<T>::value); + +public: + typedef T inherited; + + lambda_functor() {} + lambda_functor(const lambda_functor& l) : inherited(l) {} + + lambda_functor(const T& t) : inherited(t) {} + + template <class SigArgs> struct sig { + typedef typename inherited::template + sig<typename SigArgs::tail_type>::type type; + }; + + // Note that this return type deduction template is instantiated, even + // if the nullary + // operator() is not called at all. One must make sure that it does not fail. + typedef typename + inherited::template sig<null_type>::type + nullary_return_type; + + // Support for boost::result_of. + template <class Sig> struct result; + template <class F> + struct result<F()> { + typedef nullary_return_type type; + }; + template <class F, class A> + struct result<F(A)> { + typedef typename sig<tuple<F, A> >::type type; + }; + template <class F, class A, class B> + struct result<F(A, B)> { + typedef typename sig<tuple<F, A, B> >::type type; + }; + template <class F, class A, class B, class C> + struct result<F(A, B, C)> { + typedef typename sig<tuple<F, A, B, C> >::type type; + }; + + nullary_return_type operator()() const { + return inherited::template + call<nullary_return_type> + (cnull_type(), cnull_type(), cnull_type(), cnull_type()); + } + + template<class A> + typename inherited::template sig<tuple<A&> >::type + operator()(A& a) const { + return inherited::template call< + typename inherited::template sig<tuple<A&> >::type + >(a, cnull_type(), cnull_type(), cnull_type()); + } + + template<class A> + BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >) + operator()(A const& a) const { + return inherited::template call< + typename inherited::template sig<tuple<A const&> >::type + >(a, cnull_type(), cnull_type(), cnull_type()); + } + + template<class A, class B> + typename inherited::template sig<tuple<A&, B&> >::type + operator()(A& a, B& b) const { + return inherited::template call< + typename inherited::template sig<tuple<A&, B&> >::type + >(a, b, cnull_type(), cnull_type()); + } + + template<class A, class B> + BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >) + operator()(A const& a, B& b) const { + return inherited::template call< + typename inherited::template sig<tuple<A const&, B&> >::type + >(a, b, cnull_type(), cnull_type()); + } + + template<class A, class B> + BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >) + operator()(A& a, B const& b) const { + return inherited::template call< + typename inherited::template sig<tuple<A&, B const&> >::type + >(a, b, cnull_type(), cnull_type()); + } + + template<class A, class B> + BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >) + operator()(A const& a, B const& b) const { + return inherited::template call< + typename inherited::template sig<tuple<A const&, B const&> >::type + >(a, b, cnull_type(), cnull_type()); + } + + template<class A, class B, class C> + typename inherited::template sig<tuple<A&, B&, C&> >::type + operator()(A& a, B& b, C& c) const + { + return inherited::template call< + typename inherited::template sig<tuple<A&, B&, C&> >::type + >(a, b, c, cnull_type()); + } + + template<class A, class B, class C> + BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >) + operator()(A const& a, B const& b, C const& c) const + { + return inherited::template call< + typename inherited::template sig<tuple<A const&, B const&, C const&> >::type + >(a, b, c, cnull_type()); + } + + // for internal calls with env + template<CALL_TEMPLATE_ARGS> + typename inherited::template sig<tuple<CALL_REFERENCE_TYPES> >::type + internal_call(CALL_FORMAL_ARGS) const { + return inherited::template + call<typename inherited::template + sig<tuple<CALL_REFERENCE_TYPES> >::type>(CALL_ACTUAL_ARGS); + } + + template<class A> + const lambda_functor<lambda_functor_base< + other_action<assignment_action>, + boost::tuple<lambda_functor, + typename const_copy_argument <const A>::type> > > + operator=(const A& a) const { + return lambda_functor_base< + other_action<assignment_action>, + boost::tuple<lambda_functor, + typename const_copy_argument <const A>::type> > + ( boost::tuple<lambda_functor, + typename const_copy_argument <const A>::type>(*this, a) ); + } + + template<class A> + const lambda_functor<lambda_functor_base< + other_action<subscript_action>, + boost::tuple<lambda_functor, + typename const_copy_argument <const A>::type> > > + operator[](const A& a) const { + return lambda_functor_base< + other_action<subscript_action>, + boost::tuple<lambda_functor, + typename const_copy_argument <const A>::type> > + ( boost::tuple<lambda_functor, + typename const_copy_argument <const A>::type>(*this, a ) ); + } +}; + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(pop) +#endif + +} // namespace lambda +} // namespace boost + +// is_placeholder + +#include <boost/is_placeholder.hpp> + +namespace boost +{ + +template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::FIRST> > > +{ + enum _vt { value = 1 }; +}; + +template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::SECOND> > > +{ + enum _vt { value = 2 }; +}; + +template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::THIRD> > > +{ + enum _vt { value = 3 }; +}; + +} // namespace boost + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/detail/lambda_fwd.hpp b/3rdParty/Boost/src/boost/lambda/detail/lambda_fwd.hpp new file mode 100644 index 0000000..a27bfad --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/lambda_fwd.hpp @@ -0,0 +1,74 @@ +// lambda_fwd.hpp - Boost Lambda Library ------------------------------- + +// 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_FWD_HPP +#define BOOST_LAMBDA_FWD_HPP + +namespace boost { +namespace lambda { + +namespace detail { + +template<class T> struct generate_error; + +} +// -- placeholders -------------------------------------------- + +template <int I> struct placeholder; + +// function_adaptors +template <class Func> +struct function_adaptor; + +template <int I, class Act> class action; + +template <class Base> +class lambda_functor; + +template <class Act, class Args> +class lambda_functor_base; + +} // namespace lambda +} // namespace boost + + +// #define CALL_TEMPLATE_ARGS class A, class Env +// #define CALL_FORMAL_ARGS A& a, Env& env +// #define CALL_ACTUAL_ARGS a, env +// #define CALL_ACTUAL_ARGS_NO_ENV a +// #define CALL_REFERENCE_TYPES A&, Env& +// #define CALL_PLAIN_TYPES A, Env +#define CALL_TEMPLATE_ARGS class A, class B, class C, class Env +#define CALL_FORMAL_ARGS A& a, B& b, C& c, Env& env +#define CALL_ACTUAL_ARGS a, b, c, env +#define CALL_ACTUAL_ARGS_NO_ENV a, b, c +#define CALL_REFERENCE_TYPES A&, B&, C&, Env& +#define CALL_PLAIN_TYPES A, B, C, Env + +namespace boost { +namespace lambda { +namespace detail { + +template<class A1, class A2, class A3, class A4> +void do_nothing(A1&, A2&, A3&, A4&) {} + +} // detail +} // lambda +} // boost + +// prevent the warnings from unused arguments +#define CALL_USE_ARGS \ +::boost::lambda::detail::do_nothing(a, b, c, env) + + + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/detail/lambda_traits.hpp b/3rdParty/Boost/src/boost/lambda/detail/lambda_traits.hpp new file mode 100644 index 0000000..f35fa09 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/lambda_traits.hpp @@ -0,0 +1,578 @@ +// - lambda_traits.hpp --- Boost Lambda Library ---------------------------- +// +// 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_LAMBDA_TRAITS_HPP +#define BOOST_LAMBDA_LAMBDA_TRAITS_HPP + +#include "boost/type_traits/transform_traits.hpp" +#include "boost/type_traits/cv_traits.hpp" +#include "boost/type_traits/function_traits.hpp" +#include "boost/type_traits/object_traits.hpp" +#include "boost/tuple/tuple.hpp" + +namespace boost { +namespace lambda { + +// -- if construct ------------------------------------------------ +// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker + +namespace detail { + +template <bool If, class Then, class Else> struct IF { typedef Then RET; }; + +template <class Then, class Else> struct IF<false, Then, Else> { + typedef Else RET; +}; + + +// An if construct that doesn't instantiate the non-matching template: + +// Called as: +// IF_type<condition, A, B>::type +// The matching template must define the typeded 'type' +// I.e. A::type if condition is true, B::type if condition is false +// Idea from Vesa Karvonen (from C&E as well I guess) +template<class T> +struct IF_type_ +{ + typedef typename T::type type; +}; + + +template<bool C, class T, class E> +struct IF_type +{ + typedef typename + IF_type_<typename IF<C, T, E>::RET >::type type; +}; + +// helper that can be used to give typedef T to some type +template <class T> struct identity_mapping { typedef T type; }; + +// An if construct for finding an integral constant 'value' +// Does not instantiate the non-matching branch +// Called as IF_value<condition, A, B>::value +// If condition is true A::value must be defined, otherwise B::value + +template<class T> +struct IF_value_ +{ + BOOST_STATIC_CONSTANT(int, value = T::value); +}; + + +template<bool C, class T, class E> +struct IF_value +{ + BOOST_STATIC_CONSTANT(int, value = (IF_value_<typename IF<C, T, E>::RET>::value)); +}; + + +// -------------------------------------------------------------- + +// removes reference from other than function types: +template<class T> class remove_reference_if_valid +{ + + typedef typename boost::remove_reference<T>::type plainT; +public: + typedef typename IF< + boost::is_function<plainT>::value, + T, + plainT + >::RET type; + +}; + + +template<class T> struct remove_reference_and_cv { + typedef typename boost::remove_cv< + typename boost::remove_reference<T>::type + >::type type; +}; + + + +// returns a reference to the element of tuple T +template<int N, class T> struct tuple_element_as_reference { + typedef typename + boost::tuples::access_traits< + typename boost::tuples::element<N, T>::type + >::non_const_type type; +}; + +// returns the cv and reverence stripped type of a tuple element +template<int N, class T> struct tuple_element_stripped { + typedef typename + remove_reference_and_cv< + typename boost::tuples::element<N, T>::type + >::type type; +}; + +// is_lambda_functor ------------------------------------------------- + +template <class T> struct is_lambda_functor_ { + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template <class Arg> struct is_lambda_functor_<lambda_functor<Arg> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +} // end detail + + +template <class T> struct is_lambda_functor { + BOOST_STATIC_CONSTANT(bool, + value = + detail::is_lambda_functor_< + typename detail::remove_reference_and_cv<T>::type + >::value); +}; + + +namespace detail { + +// -- parameter_traits_ --------------------------------------------- + +// An internal parameter type traits class that respects +// the reference_wrapper class. + +// The conversions performed are: +// references -> compile_time_error +// T1 -> T2, +// reference_wrapper<T> -> T& +// const array -> ref to const array +// array -> ref to array +// function -> ref to function + +// ------------------------------------------------------------------------ + +template<class T1, class T2> +struct parameter_traits_ { + typedef T2 type; +}; + +// Do not instantiate with reference types +template<class T, class Any> struct parameter_traits_<T&, Any> { + typedef typename + generate_error<T&>:: + parameter_traits_class_instantiated_with_reference_type type; +}; + +// Arrays can't be stored as plain types; convert them to references +template<class T, int n, class Any> struct parameter_traits_<T[n], Any> { + typedef T (&type)[n]; +}; + +template<class T, int n, class Any> +struct parameter_traits_<const T[n], Any> { + typedef const T (&type)[n]; +}; + +template<class T, int n, class Any> +struct parameter_traits_<volatile T[n], Any> { + typedef volatile T (&type)[n]; +}; +template<class T, int n, class Any> +struct parameter_traits_<const volatile T[n], Any> { + typedef const volatile T (&type)[n]; +}; + + +template<class T, class Any> +struct parameter_traits_<boost::reference_wrapper<T>, Any >{ + typedef T& type; +}; + +template<class T, class Any> +struct parameter_traits_<const boost::reference_wrapper<T>, Any >{ + typedef T& type; +}; + +template<class T, class Any> +struct parameter_traits_<volatile boost::reference_wrapper<T>, Any >{ + typedef T& type; +}; + +template<class T, class Any> +struct parameter_traits_<const volatile boost::reference_wrapper<T>, Any >{ + typedef T& type; +}; + +template<class Any> +struct parameter_traits_<void, Any> { + typedef void type; +}; + +template<class Arg, class Any> +struct parameter_traits_<lambda_functor<Arg>, Any > { + typedef lambda_functor<Arg> type; +}; + +template<class Arg, class Any> +struct parameter_traits_<const lambda_functor<Arg>, Any > { + typedef lambda_functor<Arg> type; +}; + +// Are the volatile versions needed? +template<class Arg, class Any> +struct parameter_traits_<volatile lambda_functor<Arg>, Any > { + typedef lambda_functor<Arg> type; +}; + +template<class Arg, class Any> +struct parameter_traits_<const volatile lambda_functor<Arg>, Any > { + typedef lambda_functor<Arg> type; +}; + +} // end namespace detail + + +// ------------------------------------------------------------------------ +// traits classes for lambda expressions (bind functions, operators ...) + +// must be instantiated with non-reference types + +// The default is const plain type ------------------------- +// const T -> const T, +// T -> const T, +// references -> compile_time_error +// reference_wrapper<T> -> T& +// array -> const ref array +template<class T> +struct const_copy_argument { + typedef typename + detail::parameter_traits_< + T, + typename detail::IF<boost::is_function<T>::value, T&, const T>::RET + >::type type; +}; + +// T may be a function type. Without the IF test, const would be added +// to a function type, which is illegal. + +// all arrays are converted to const. +// This traits template is used for 'const T&' parameter passing +// and thus the knowledge of the potential +// non-constness of an actual argument is lost. +template<class T, int n> struct const_copy_argument <T[n]> { + typedef const T (&type)[n]; +}; +template<class T, int n> struct const_copy_argument <volatile T[n]> { + typedef const volatile T (&type)[n]; +}; + +template<class T> +struct const_copy_argument<T&> {}; +// do not instantiate with references + // typedef typename detail::generate_error<T&>::references_not_allowed type; + + +template<> +struct const_copy_argument<void> { + typedef void type; +}; + + +// Does the same as const_copy_argument, but passes references through as such +template<class T> +struct bound_argument_conversion { + typedef typename const_copy_argument<T>::type type; +}; + +template<class T> +struct bound_argument_conversion<T&> { + typedef T& type; +}; + +// The default is non-const reference ------------------------- +// const T -> const T&, +// T -> T&, +// references -> compile_time_error +// reference_wrapper<T> -> T& +template<class T> +struct reference_argument { + typedef typename detail::parameter_traits_<T, T&>::type type; +}; + +template<class T> +struct reference_argument<T&> { + typedef typename detail::generate_error<T&>::references_not_allowed type; +}; + +template<class Arg> +struct reference_argument<lambda_functor<Arg> > { + typedef lambda_functor<Arg> type; +}; + +template<class Arg> +struct reference_argument<const lambda_functor<Arg> > { + typedef lambda_functor<Arg> type; +}; + +// Are the volatile versions needed? +template<class Arg> +struct reference_argument<volatile lambda_functor<Arg> > { + typedef lambda_functor<Arg> type; +}; + +template<class Arg> +struct reference_argument<const volatile lambda_functor<Arg> > { + typedef lambda_functor<Arg> type; +}; + +template<> +struct reference_argument<void> { + typedef void type; +}; + +namespace detail { + +// Array to pointer conversion +template <class T> +struct array_to_pointer { + typedef T type; +}; + +template <class T, int N> +struct array_to_pointer <const T[N]> { + typedef const T* type; +}; +template <class T, int N> +struct array_to_pointer <T[N]> { + typedef T* type; +}; + +template <class T, int N> +struct array_to_pointer <const T (&) [N]> { + typedef const T* type; +}; +template <class T, int N> +struct array_to_pointer <T (&) [N]> { + typedef T* type; +}; + + +// --------------------------------------------------------------------------- +// The call_traits for bind +// Respects the reference_wrapper class. + +// These templates are used outside of bind functions as well. +// the bind_tuple_mapper provides a shorter notation for default +// bound argument storing semantics, if all arguments are treated +// uniformly. + +// from template<class T> foo(const T& t) : bind_traits<const T>::type +// from template<class T> foo(T& t) : bind_traits<T>::type + +// Conversions: +// T -> const T, +// cv T -> cv T, +// T& -> T& +// reference_wrapper<T> -> T& +// const reference_wrapper<T> -> T& +// array -> const ref array + +// make bound arguments const, this is a deliberate design choice, the +// purpose is to prevent side effects to bound arguments that are stored +// as copies +template<class T> +struct bind_traits { + typedef const T type; +}; + +template<class T> +struct bind_traits<T&> { + typedef T& type; +}; + +// null_types are an exception, we always want to store them as non const +// so that other templates can assume that null_type is always without const +template<> +struct bind_traits<null_type> { + typedef null_type type; +}; + +// the bind_tuple_mapper, bind_type_generators may +// introduce const to null_type +template<> +struct bind_traits<const null_type> { + typedef null_type type; +}; + +// Arrays can't be stored as plain types; convert them to references. +// All arrays are converted to const. This is because bind takes its +// parameters as const T& and thus the knowledge of the potential +// non-constness of actual argument is lost. +template<class T, int n> struct bind_traits <T[n]> { + typedef const T (&type)[n]; +}; + +template<class T, int n> +struct bind_traits<const T[n]> { + typedef const T (&type)[n]; +}; + +template<class T, int n> struct bind_traits<volatile T[n]> { + typedef const volatile T (&type)[n]; +}; + +template<class T, int n> +struct bind_traits<const volatile T[n]> { + typedef const volatile T (&type)[n]; +}; + +template<class R> +struct bind_traits<R()> { + typedef R(&type)(); +}; + +template<class R, class Arg1> +struct bind_traits<R(Arg1)> { + typedef R(&type)(Arg1); +}; + +template<class R, class Arg1, class Arg2> +struct bind_traits<R(Arg1, Arg2)> { + typedef R(&type)(Arg1, Arg2); +}; + +template<class R, class Arg1, class Arg2, class Arg3> +struct bind_traits<R(Arg1, Arg2, Arg3)> { + typedef R(&type)(Arg1, Arg2, Arg3); +}; + +template<class R, class Arg1, class Arg2, class Arg3, class Arg4> +struct bind_traits<R(Arg1, Arg2, Arg3, Arg4)> { + typedef R(&type)(Arg1, Arg2, Arg3, Arg4); +}; + +template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> +struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5)> { + typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5); +}; + +template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6> +struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { + typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6); +}; + +template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7> +struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { + typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7); +}; + +template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8> +struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { + typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8); +}; + +template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9> +struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> { + typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9); +}; + +template<class T> +struct bind_traits<reference_wrapper<T> >{ + typedef T& type; +}; + +template<class T> +struct bind_traits<const reference_wrapper<T> >{ + typedef T& type; +}; + +template<> +struct bind_traits<void> { + typedef void type; +}; + + + +template < + class T0 = null_type, class T1 = null_type, class T2 = null_type, + class T3 = null_type, class T4 = null_type, class T5 = null_type, + class T6 = null_type, class T7 = null_type, class T8 = null_type, + class T9 = null_type +> +struct bind_tuple_mapper { + typedef + tuple<typename bind_traits<T0>::type, + typename bind_traits<T1>::type, + typename bind_traits<T2>::type, + typename bind_traits<T3>::type, + typename bind_traits<T4>::type, + typename bind_traits<T5>::type, + typename bind_traits<T6>::type, + typename bind_traits<T7>::type, + typename bind_traits<T8>::type, + typename bind_traits<T9>::type> type; +}; + +// bind_traits, except map const T& -> const T + // this is needed e.g. in currying. Const reference arguments can + // refer to temporaries, so it is not safe to store them as references. + template <class T> struct remove_const_reference { + typedef typename bind_traits<T>::type type; + }; + + template <class T> struct remove_const_reference<const T&> { + typedef const T type; + }; + + +// maps the bind argument types to the resulting lambda functor type +template < + class T0 = null_type, class T1 = null_type, class T2 = null_type, + class T3 = null_type, class T4 = null_type, class T5 = null_type, + class T6 = null_type, class T7 = null_type, class T8 = null_type, + class T9 = null_type +> +class bind_type_generator { + + typedef typename + detail::bind_tuple_mapper< + T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 + >::type args_t; + + BOOST_STATIC_CONSTANT(int, nof_elems = boost::tuples::length<args_t>::value); + + typedef + action< + nof_elems, + function_action<nof_elems> + > action_type; + +public: + typedef + lambda_functor< + lambda_functor_base< + action_type, + args_t + > + > type; + +}; + + + +} // detail + +template <class T> inline const T& make_const(const T& t) { return t; } + + +} // end of namespace lambda +} // end of namespace boost + + + +#endif // BOOST_LAMBDA_TRAITS_HPP diff --git a/3rdParty/Boost/src/boost/lambda/detail/member_ptr.hpp b/3rdParty/Boost/src/boost/lambda/detail/member_ptr.hpp new file mode 100644 index 0000000..288f70c --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/member_ptr.hpp @@ -0,0 +1,737 @@ +// Boost Lambda Library -- member_ptr.hpp --------------------- + +// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) +// Copyright (C) 2000 Gary Powell (gary.powell@sierra.com) +// +// 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 + +// -------------------------------------------------------------------------- + +#if !defined(BOOST_LAMBDA_MEMBER_PTR_HPP) +#define BOOST_LAMBDA_MEMBER_PTR_HPP + +namespace boost { +namespace lambda { + + +class member_pointer_action {}; + + +namespace detail { + +// the boost type_traits member_pointer traits are not enough, +// need to know more details. +template<class T> +struct member_pointer { + typedef typename boost::add_reference<T>::type type; + typedef detail::unspecified class_type; + typedef detail::unspecified qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = false); +}; + +template<class T, class U> +struct member_pointer<T U::*> { + typedef typename boost::add_reference<T>::type type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = true); + BOOST_STATIC_CONSTANT(bool, is_function_member = false); +}; + +template<class T, class U> +struct member_pointer<const T U::*> { + typedef typename boost::add_reference<const T>::type type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = true); + BOOST_STATIC_CONSTANT(bool, is_function_member = false); +}; + +template<class T, class U> +struct member_pointer<volatile T U::*> { + typedef typename boost::add_reference<volatile T>::type type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = true); + BOOST_STATIC_CONSTANT(bool, is_function_member = false); +}; + +template<class T, class U> +struct member_pointer<const volatile T U::*> { + typedef typename boost::add_reference<const volatile T>::type type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = true); + BOOST_STATIC_CONSTANT(bool, is_function_member = false); +}; + +// -- nonconst member functions -- +template<class T, class U> +struct member_pointer<T (U::*)()> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1> +struct member_pointer<T (U::*)(A1)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2> +struct member_pointer<T (U::*)(A1, A2)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3> +struct member_pointer<T (U::*)(A1, A2, A3)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4> +struct member_pointer<T (U::*)(A1, A2, A3, A4)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8, class A9> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)> { + typedef T type; + typedef U class_type; + typedef U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +// -- const member functions -- +template<class T, class U> +struct member_pointer<T (U::*)() const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1> +struct member_pointer<T (U::*)(A1) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2> +struct member_pointer<T (U::*)(A1, A2) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3> +struct member_pointer<T (U::*)(A1, A2, A3) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4> +struct member_pointer<T (U::*)(A1, A2, A3, A4) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8, class A9> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const> { + typedef T type; + typedef U class_type; + typedef const U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; + // -- volatile -- +template<class T, class U> +struct member_pointer<T (U::*)() volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1> +struct member_pointer<T (U::*)(A1) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2> +struct member_pointer<T (U::*)(A1, A2) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3> +struct member_pointer<T (U::*)(A1, A2, A3) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4> +struct member_pointer<T (U::*)(A1, A2, A3, A4) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8, class A9> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) volatile> { + typedef T type; + typedef U class_type; + typedef volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; + // -- const volatile +template<class T, class U> +struct member_pointer<T (U::*)() const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1> +struct member_pointer<T (U::*)(A1) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2> +struct member_pointer<T (U::*)(A1, A2) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3> +struct member_pointer<T (U::*)(A1, A2, A3) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4> +struct member_pointer<T (U::*)(A1, A2, A3, A4) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; +template<class T, class U, class A1, class A2, class A3, class A4, class A5, + class A6, class A7, class A8, class A9> +struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const volatile> { + typedef T type; + typedef U class_type; + typedef const volatile U qualified_class_type; + BOOST_STATIC_CONSTANT(bool, is_data_member = false); + BOOST_STATIC_CONSTANT(bool, is_function_member = true); +}; + +} // detail + +namespace detail { + + // this class holds a pointer to a member function and the object. + // when called, it just calls the member function with the parameters + // provided + + // It would have been possible to use existing lambda_functors to represent + // a bound member function like this, but to have a separate template is + // safer, since now this functor doesn't mix and match with lambda_functors + // only thing you can do with this is to call it + + // note that previously instantiated classes + // (other_action<member_pointer_action> and member_pointer_action_helper + // guarantee, that A and B are + // such types, that for objects a and b of corresponding types, a->*b leads + // to the builtin ->* to be called. So types that would end in a call to + // a user defined ->* do not create a member_pointer_caller object. + +template<class RET, class A, class B> +class member_pointer_caller { + A a; B b; + +public: + member_pointer_caller(const A& aa, const B& bb) : a(aa), b(bb) {} + + RET operator()() const { return (a->*b)(); } + + template<class A1> + RET operator()(const A1& a1) const { return (a->*b)(a1); } + + template<class A1, class A2> + RET operator()(const A1& a1, const A2& a2) const { return (a->*b)(a1, a2); } + + template<class A1, class A2, class A3> + RET operator()(const A1& a1, const A2& a2, const A3& a3) const { + return (a->*b)(a1, a2, a3); + } + + template<class A1, class A2, class A3, class A4> + RET operator()(const A1& a1, const A2& a2, const A3& a3, + const A4& a4) const { + return (a->*b)(a1, a2, a3, a4); + } + + template<class A1, class A2, class A3, class A4, class A5> + RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, + const A5& a5) const { + return (a->*b)(a1, a2, a3, a4, a5); + } + + template<class A1, class A2, class A3, class A4, class A5, class A6> + RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, + const A5& a5, const A6& a6) const { + return (a->*b)(a1, a2, a3, a4, a5, a6); + } + + template<class A1, class A2, class A3, class A4, class A5, class A6, + class A7> + RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, + const A5& a5, const A6& a6, const A7& a7) const { + return (a->*b)(a1, a2, a3, a4, a5, a6, a7); + } + + template<class A1, class A2, class A3, class A4, class A5, class A6, + class A7, class A8> + RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, + const A5& a5, const A6& a6, const A7& a7, + const A8& a8) const { + return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8); + } + + template<class A1, class A2, class A3, class A4, class A5, class A6, + class A7, class A8, class A9> + RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, + const A5& a5, const A6& a6, const A7& a7, + const A8& a8, const A9& a9) const { + return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } + +}; + +// helper templates for return type deduction and action classes +// different cases for data member, function member, neither + +// true-true case +template <bool Is_data_member, bool Is_function_member> +struct member_pointer_action_helper; + // cannot be both, no body provided + + // data member case + // this means, that B is a data member and A is a pointer type, + // so either built-in ->* should be called, or there is an error +template <> +struct member_pointer_action_helper<true, false> { +public: + + template<class RET, class A, class B> + static RET apply(A& a, B& b) { + return a->*b; + } + + template<class A, class B> + struct return_type { + private: + typedef typename detail::remove_reference_and_cv<B>::type plainB; + + typedef typename detail::member_pointer<plainB>::type type0; + // we remove the reference now, as we may have to add cv:s + typedef typename boost::remove_reference<type0>::type type1; + + // A is a reference to pointer + // remove the top level cv qualifiers and reference + typedef typename + detail::remove_reference_and_cv<A>::type non_ref_A; + + // A is a pointer type, so take the type pointed to + typedef typename ::boost::remove_pointer<non_ref_A>::type non_pointer_A; + + public: + // For non-reference types, we must add const and/or volatile if + // the pointer type has these qualifiers + // If the member is a reference, these do not have any effect + // (cv T == T if T is a reference type) + typedef typename detail::IF< + ::boost::is_const<non_pointer_A>::value, + typename ::boost::add_const<type1>::type, + type1 + >::RET type2; + typedef typename detail::IF< + ::boost::is_volatile<non_pointer_A>::value, + typename ::boost::add_volatile<type2>::type, + type2 + >::RET type3; + // add reference back + typedef typename ::boost::add_reference<type3>::type type; + }; +}; + + // neither case +template <> +struct member_pointer_action_helper<false, false> { +public: + template<class RET, class A, class B> + static RET apply(A& a, B& b) { +// not a built in member pointer operator, just call ->* + return a->*b; + } + // an overloaded member pointer operators, user should have specified + // the return type + // At this point we know that there is no matching specialization for + // return_type_2, so try return_type_2_plain + template<class A, class B> + struct return_type { + + typedef typename plain_return_type_2< + other_action<member_pointer_action>, A, B + >::type type; + }; + +}; + + +// member pointer function case +// This is a built in ->* call for a member function, +// the only thing that you can do with that, is to give it some arguments +// note, it is guaranteed that A is a pointer type, and thus it cannot +// be a call to overloaded ->* +template <> +struct member_pointer_action_helper<false, true> { + public: + + template<class RET, class A, class B> + static RET apply(A& a, B& b) { + typedef typename ::boost::remove_cv<B>::type plainB; + typedef typename detail::member_pointer<plainB>::type ret_t; + typedef typename ::boost::remove_cv<A>::type plainA; + + // we always strip cv:s to + // make the two routes (calling and type deduction) + // to give the same results (and the const does not make any functional + // difference) + return detail::member_pointer_caller<ret_t, plainA, plainB>(a, b); + } + + template<class A, class B> + struct return_type { + typedef typename detail::remove_reference_and_cv<B>::type plainB; + typedef typename detail::member_pointer<plainB>::type ret_t; + typedef typename detail::remove_reference_and_cv<A>::type plainA; + + typedef detail::member_pointer_caller<ret_t, plainA, plainB> type; + }; +}; + +} // detail + +template<> class other_action<member_pointer_action> { +public: + template<class RET, class A, class B> + static RET apply(A& a, B& b) { + typedef typename + ::boost::remove_cv<B>::type plainB; + + return detail::member_pointer_action_helper< + boost::is_pointer<A>::value && + detail::member_pointer<plainB>::is_data_member, + boost::is_pointer<A>::value && + detail::member_pointer<plainB>::is_function_member + >::template apply<RET>(a, b); + } +}; + + // return type deduction -- + + // If the right argument is a pointer to data member, + // and the left argument is of compatible pointer to class type + // return type is a reference to the data member type + + // if right argument is a pointer to a member function, and the left + // argument is of a compatible type, the return type is a + // member_pointer_caller (see above) + + // Otherwise, return type deduction fails. There is either an error, + // or the user is trying to call an overloaded ->* + // In such a case either ret<> must be used, or a return_type_2 user + // defined specialization must be provided + + +template<class A, class B> +struct return_type_2<other_action<member_pointer_action>, A, B> { +private: + typedef typename + detail::remove_reference_and_cv<B>::type plainB; +public: + typedef typename + detail::member_pointer_action_helper< + detail::member_pointer<plainB>::is_data_member, + detail::member_pointer<plainB>::is_function_member + >::template return_type<A, B>::type type; +}; + + // this is the way the generic lambda_functor_base functions instantiate + // return type deduction. We turn it into return_type_2, so that the + // user can provide specializations on that level. +template<class Args> +struct return_type_N<other_action<member_pointer_action>, Args> { + typedef typename boost::tuples::element<0, Args>::type A; + typedef typename boost::tuples::element<1, Args>::type B; + typedef typename + return_type_2<other_action<member_pointer_action>, + typename boost::remove_reference<A>::type, + typename boost::remove_reference<B>::type + >::type type; +}; + + +template<class Arg1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, other_action<member_pointer_action> >, + tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type> + > +> +operator->*(const lambda_functor<Arg1>& a1, const Arg2& a2) +{ + return + lambda_functor_base< + action<2, other_action<member_pointer_action> >, + tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type> + > + (tuple<lambda_functor<Arg1>, + typename const_copy_argument<Arg2>::type>(a1, a2)); +} + +template<class Arg1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, other_action<member_pointer_action> >, + tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > + > +> +operator->*(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) +{ + return + lambda_functor_base< + action<2, other_action<member_pointer_action> >, + tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > + > + (tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2)); +} + +template<class Arg1, class Arg2> +inline const +lambda_functor< + lambda_functor_base< + action<2, other_action<member_pointer_action> >, + tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> > + > +> +operator->*(const Arg1& a1, const lambda_functor<Arg2>& a2) +{ + return + lambda_functor_base< + action<2, other_action<member_pointer_action> >, + tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> > + > + (tuple<typename const_copy_argument<Arg1>::type, + lambda_functor<Arg2> >(a1, a2)); +} + + +} // namespace lambda +} // namespace boost + + +#endif + + + + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/operator_actions.hpp b/3rdParty/Boost/src/boost/lambda/detail/operator_actions.hpp new file mode 100644 index 0000000..949b40f --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/operator_actions.hpp @@ -0,0 +1,139 @@ +// -- operator_actions.hpp - Boost Lambda Library ---------------------- + +// 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 http://lambda.cs.utu.fi + +#ifndef BOOST_LAMBDA_OPERATOR_ACTIONS_HPP +#define BOOST_LAMBDA_OPERATOR_ACTIONS_HPP + +namespace boost { +namespace lambda { + + +// -- artihmetic ---------------------- + +class plus_action {}; +class minus_action {}; +class multiply_action {}; +class divide_action {}; +class remainder_action {}; + +// -- bitwise ------------------- + +class leftshift_action {}; +class rightshift_action {}; +class xor_action {}; + + +// -- bitwise/logical ------------------- + +class and_action {}; +class or_action {}; +class not_action {}; + +// -- relational ------------------------- + +class less_action {}; +class greater_action {}; +class lessorequal_action {}; +class greaterorequal_action {}; +class equal_action {}; +class notequal_action {}; + +// -- increment/decrement ------------------------------ + +class increment_action {}; +class decrement_action {}; + +// -- void return ------------------------------ + +// -- other ------------------------------ + +class addressof_action {}; + // class comma_action {}; // defined in actions.hpp +class contentsof_action {}; +// class member_pointer_action {}; (defined in member_ptr.hpp) + + +// -- actioun group templates -------------------- + +template <class Action> class arithmetic_action; +template <class Action> class bitwise_action; +template <class Action> class logical_action; +template <class Action> class relational_action; +template <class Action> class arithmetic_assignment_action; +template <class Action> class bitwise_assignment_action; +template <class Action> class unary_arithmetic_action; +template <class Action> class pre_increment_decrement_action; +template <class Action> class post_increment_decrement_action; + +// --------------------------------------------------------- + + // actions, for which the existence of protect is checked in return type + // deduction. + +template <class Act> struct is_protectable<arithmetic_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> struct is_protectable<bitwise_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> struct is_protectable<logical_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> struct is_protectable<relational_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> +struct is_protectable<arithmetic_assignment_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> struct is_protectable<bitwise_assignment_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> struct is_protectable<unary_arithmetic_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> +struct is_protectable<pre_increment_decrement_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <class Act> struct +is_protectable<post_increment_decrement_action<Act> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template <> struct is_protectable<other_action<addressof_action> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template <> struct is_protectable<other_action<contentsof_action> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template<> struct is_protectable<other_action<subscript_action> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; +template<> struct is_protectable<other_action<assignment_action> > { + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +// NOTE: comma action is also protectable, but the specialization is + // in actions.hpp + + +} // namespace lambda +} // namespace boost + +#endif + + + + + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/operator_lambda_func_base.hpp b/3rdParty/Boost/src/boost/lambda/detail/operator_lambda_func_base.hpp new file mode 100644 index 0000000..12a6d93 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/operator_lambda_func_base.hpp @@ -0,0 +1,271 @@ +// Boost Lambda Library - operator_lambda_func_base.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_OPERATOR_LAMBDA_FUNC_BASE_HPP +#define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP + +namespace boost { +namespace lambda { + + +// These operators cannot be implemented as apply functions of action +// templates + + +// Specialization for comma. +template<class Args> +class lambda_functor_base<other_action<comma_action>, Args> { +public: + Args args; +public: + explicit lambda_functor_base(const Args& a) : args(a) {} + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { + return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS), + detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); + } + + + template<class SigArgs> struct sig { + private: + typedef typename + detail::deduce_argument_types<Args, SigArgs>::type rets_t; + public: + typedef typename return_type_2_comma< // comma needs special handling + typename detail::element_or_null<0, rets_t>::type, + typename detail::element_or_null<1, rets_t>::type + >::type type; + }; + +}; + +namespace detail { + +// helper traits to make the expression shorter, takes binary action +// bound argument tuple, open argument tuple and gives the return type + +template<class Action, class Bound, class Open> class binary_rt { + private: + typedef typename + detail::deduce_argument_types<Bound, Open>::type rets_t; + public: + typedef typename return_type_2_prot< + Action, + typename detail::element_or_null<0, rets_t>::type, + typename detail::element_or_null<1, rets_t>::type + >::type type; +}; + + + // same for unary actions +template<class Action, class Bound, class Open> class unary_rt { + private: + typedef typename + detail::deduce_argument_types<Bound, Open>::type rets_t; + public: + typedef typename return_type_1_prot< + Action, + typename detail::element_or_null<0, rets_t>::type + >::type type; +}; + + +} // end detail + +// Specialization for logical and (to preserve shortcircuiting) +// this could be done with a macro as the others, code used to be different +template<class Args> +class lambda_functor_base<logical_action<and_action>, Args> { +public: + Args args; +public: + explicit lambda_functor_base(const Args& a) : args(a) {} + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { + return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) && + detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); + } + template<class SigArgs> struct sig { + typedef typename + detail::binary_rt<logical_action<and_action>, Args, SigArgs>::type type; + }; +}; + +// Specialization for logical or (to preserve shortcircuiting) +// this could be done with a macro as the others, code used to be different +template<class Args> +class lambda_functor_base<logical_action< or_action>, Args> { +public: + Args args; +public: + explicit lambda_functor_base(const Args& a) : args(a) {} + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { + return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) || + detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); + } + + template<class SigArgs> struct sig { + typedef typename + detail::binary_rt<logical_action<or_action>, Args, SigArgs>::type type; + }; +}; + +// Specialization for subscript +template<class Args> +class lambda_functor_base<other_action<subscript_action>, Args> { +public: + Args args; +public: + explicit lambda_functor_base(const Args& a) : args(a) {} + + template<class RET, CALL_TEMPLATE_ARGS> + RET call(CALL_FORMAL_ARGS) const { + return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) + [detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)]; + } + + template<class SigArgs> struct sig { + typedef typename + detail::binary_rt<other_action<subscript_action>, Args, SigArgs>::type + type; + }; +}; + + +#define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS) \ +template<class Args> \ +class lambda_functor_base<ACTION_CLASS, Args> { \ +public: \ + Args args; \ +public: \ + explicit lambda_functor_base(const Args& a) : args(a) {} \ + \ + template<class RET, CALL_TEMPLATE_ARGS> \ + RET call(CALL_FORMAL_ARGS) const { \ + return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) \ + SYMBOL \ + detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \ + } \ + template<class SigArgs> struct sig { \ + typedef typename \ + detail::binary_rt<ACTION_CLASS, Args, SigArgs>::type type; \ + }; \ +}; + +#define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \ +template<class Args> \ +class lambda_functor_base<ACTION_CLASS, Args> { \ +public: \ + Args args; \ +public: \ + explicit lambda_functor_base(const Args& a) : args(a) {} \ + \ + template<class RET, CALL_TEMPLATE_ARGS> \ + RET call(CALL_FORMAL_ARGS) const { \ + return SYMBOL \ + detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); \ + } \ + template<class SigArgs> struct sig { \ + typedef typename \ + detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \ + }; \ +}; + +#define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \ +template<class Args> \ +class lambda_functor_base<ACTION_CLASS, Args> { \ +public: \ + Args args; \ +public: \ + explicit lambda_functor_base(const Args& a) : args(a) {} \ + \ + template<class RET, CALL_TEMPLATE_ARGS> \ + RET call(CALL_FORMAL_ARGS) const { \ + return \ + detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) SYMBOL; \ + } \ + template<class SigArgs> struct sig { \ + typedef typename \ + detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \ + }; \ +}; + +BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>) +BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>) +BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>) +BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>) +BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>) + +BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>) +BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>) +BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>) +BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>) +BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>) + +BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>) +BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>) +BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>) +BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>) +BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>) +BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>) + +BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>) +BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>) +BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>) +BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>) +BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>) + +BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>) +BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>) +BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>) +BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>) +BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>) + +BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>) + + +BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>) +BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>) +BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>) +BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>) +BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>) +BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>) + +BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>) +BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>) + +BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>) +BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>) + + +#undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION +#undef BOOST_LAMBDA_PREFIX_UNARY_ACTION +#undef BOOST_LAMBDA_BINARY_ACTION + +} // namespace lambda +} // namespace boost + +#endif + + + + + + + + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp b/3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp new file mode 100644 index 0000000..b2d3d3a --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp @@ -0,0 +1,917 @@ +// operator_return_type_traits.hpp -- Boost Lambda Library ------------------ + +// 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_OPERATOR_RETURN_TYPE_TRAITS_HPP +#define BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP + +#include "boost/lambda/detail/is_instance_of.hpp" +#include "boost/type_traits/same_traits.hpp" + +#include "boost/indirect_reference.hpp" +#include "boost/detail/container_fwd.hpp" + +#include <cstddef> // needed for the ptrdiff_t +#include <iosfwd> // for istream and ostream + +#include <iterator> // needed for operator& + +namespace boost { +namespace lambda { +namespace detail { + +// -- general helper templates for type deduction ------------------ + +// Much of the type deduction code for standard arithmetic types from Gary Powell + +template <class A> struct promote_code { static const int value = -1; }; +// this means that a code is not defined for A + +// -- the next 5 types are needed in if_then_else_return +// the promotion order is not important, but they must have distinct values. +template <> struct promote_code<bool> { static const int value = 10; }; +template <> struct promote_code<char> { static const int value = 20; }; +template <> struct promote_code<unsigned char> { static const int value = 30; }; +template <> struct promote_code<signed char> { static const int value = 40; }; +template <> struct promote_code<short int> { static const int value = 50; }; +// ---------- + +template <> struct promote_code<int> { static const int value = 100; }; +template <> struct promote_code<unsigned int> { static const int value = 200; }; +template <> struct promote_code<long> { static const int value = 300; }; +template <> struct promote_code<unsigned long> { static const int value = 400; }; + +template <> struct promote_code<float> { static const int value = 500; }; +template <> struct promote_code<double> { static const int value = 600; }; +template <> struct promote_code<long double> { static const int value = 700; }; + +// TODO: wchar_t + +// forward delcaration of complex. + +} // namespace detail +} // namespace lambda +} // namespace boost + +namespace boost { +namespace lambda { +namespace detail { + +template <> struct promote_code< std::complex<float> > { static const int value = 800; }; +template <> struct promote_code< std::complex<double> > { static const int value = 900; }; +template <> struct promote_code< std::complex<long double> > { static const int value = 1000; }; + +// -- int promotion ------------------------------------------- +template <class T> struct promote_to_int { typedef T type; }; + +template <> struct promote_to_int<bool> { typedef int type; }; +template <> struct promote_to_int<char> { typedef int type; }; +template <> struct promote_to_int<unsigned char> { typedef int type; }; +template <> struct promote_to_int<signed char> { typedef int type; }; +template <> struct promote_to_int<short int> { typedef int type; }; + +// The unsigned short int promotion rule is this: +// unsigned short int to signed int if a signed int can hold all values +// of unsigned short int, otherwise go to unsigned int. +template <> struct promote_to_int<unsigned short int> +{ + typedef + detail::IF<sizeof(int) <= sizeof(unsigned short int), +// I had the logic reversed but ">" messes up the parsing. + unsigned int, + int>::RET type; +}; + + +// TODO: think, should there be default behaviour for non-standard types? + +} // namespace detail + +// ------------------------------------------ +// Unary actions ---------------------------- +// ------------------------------------------ + +template<class Act, class A> +struct plain_return_type_1 { + typedef detail::unspecified type; +}; + + + +template<class Act, class A> +struct plain_return_type_1<unary_arithmetic_action<Act>, A> { + typedef A type; +}; + +template<class Act, class A> +struct return_type_1<unary_arithmetic_action<Act>, A> { + typedef + typename plain_return_type_1< + unary_arithmetic_action<Act>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + + +template<class A> +struct plain_return_type_1<bitwise_action<not_action>, A> { + typedef A type; +}; + +// bitwise not, operator~() +template<class A> struct return_type_1<bitwise_action<not_action>, A> { + typedef + typename plain_return_type_1< + bitwise_action<not_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + + +// prefix increment and decrement operators return +// their argument by default as a non-const reference +template<class Act, class A> +struct plain_return_type_1<pre_increment_decrement_action<Act>, A> { + typedef A& type; +}; + +template<class Act, class A> +struct return_type_1<pre_increment_decrement_action<Act>, A> { + typedef + typename plain_return_type_1< + pre_increment_decrement_action<Act>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + +// post decrement just returns the same plain type. +template<class Act, class A> +struct plain_return_type_1<post_increment_decrement_action<Act>, A> { + typedef A type; +}; + +template<class Act, class A> +struct return_type_1<post_increment_decrement_action<Act>, A> +{ + typedef + typename plain_return_type_1< + post_increment_decrement_action<Act>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + +// logical not, operator!() +template<class A> +struct plain_return_type_1<logical_action<not_action>, A> { + typedef bool type; +}; + +template<class A> +struct return_type_1<logical_action<not_action>, A> { + typedef + typename plain_return_type_1< + logical_action<not_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + +// address of action --------------------------------------- + + +template<class A> +struct return_type_1<other_action<addressof_action>, A> { + typedef + typename plain_return_type_1< + other_action<addressof_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type1; + + // If no user defined specialization for A, then return the + // cv qualified pointer to A + typedef typename detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::remove_reference<A>::type*, + type1 + >::RET type; +}; + +// contentsof action ------------------------------------ + +// TODO: this deduction may lead to fail directly, +// (if A has no specialization for iterator_traits and has no +// typedef A::reference. +// There is no easy way around this, cause there doesn't seem to be a way +// to test whether a class is an iterator or not. + +// The default works with std::iterators. + +namespace detail { + + // A is a nonreference type +template <class A> struct contentsof_type { + typedef typename boost::indirect_reference<A>::type type; +}; + + // this is since the nullary () in lambda_functor is always instantiated +template <> struct contentsof_type<null_type> { + typedef detail::unspecified type; +}; + + +template <class A> struct contentsof_type<const A> { + typedef typename contentsof_type<A>::type type; +}; + +template <class A> struct contentsof_type<volatile A> { + typedef typename contentsof_type<A>::type type; +}; + +template <class A> struct contentsof_type<const volatile A> { + typedef typename contentsof_type<A>::type type; +}; + + // standard iterator traits should take care of the pointer types + // but just to be on the safe side, we have the specializations here: + // these work even if A is cv-qualified. +template <class A> struct contentsof_type<A*> { + typedef A& type; +}; +template <class A> struct contentsof_type<A* const> { + typedef A& type; +}; +template <class A> struct contentsof_type<A* volatile> { + typedef A& type; +}; +template <class A> struct contentsof_type<A* const volatile> { + typedef A& type; +}; + +template<class A, int N> struct contentsof_type<A[N]> { + typedef A& type; +}; +template<class A, int N> struct contentsof_type<const A[N]> { + typedef const A& type; +}; +template<class A, int N> struct contentsof_type<volatile A[N]> { + typedef volatile A& type; +}; +template<class A, int N> struct contentsof_type<const volatile A[N]> { + typedef const volatile A& type; +}; + + + + + +} // end detail + +template<class A> +struct return_type_1<other_action<contentsof_action>, A> { + + typedef + typename plain_return_type_1< + other_action<contentsof_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type1; + + // If no user defined specialization for A, then return the + // cv qualified pointer to A + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::contentsof_type< + typename boost::remove_reference<A>::type + >, + detail::identity_mapping<type1> + >::type type; +}; + + +// ------------------------------------------------------------------ +// binary actions --------------------------------------------------- +// ------------------------------------------------------------------ + +// here the default case is: no user defined versions: +template <class Act, class A, class B> +struct plain_return_type_2 { + typedef detail::unspecified type; +}; + +namespace detail { + +// error classes +class illegal_pointer_arithmetic{}; + +// pointer arithmetic type deductions ---------------------- +// value = false means that this is not a pointer arithmetic case +// value = true means, that this can be a pointer arithmetic case, but not necessarily is +// This means, that for user defined operators for pointer types, say for some operator+(X, *Y), +// the deductions must be coded at an earliel level (return_type_2). + +template<class Act, class A, class B> +struct pointer_arithmetic_traits { static const bool value = false; }; + +template<class A, class B> +struct pointer_arithmetic_traits<plus_action, A, B> { + + typedef typename + array_to_pointer<typename boost::remove_reference<A>::type>::type AP; + typedef typename + array_to_pointer<typename boost::remove_reference<B>::type>::type BP; + + static const bool is_pointer_A = boost::is_pointer<AP>::value; + static const bool is_pointer_B = boost::is_pointer<BP>::value; + + static const bool value = is_pointer_A || is_pointer_B; + + // can't add two pointers. + // note, that we do not check wether the other type is valid for + // addition with a pointer. + // the compiler will catch it in the apply function + + typedef typename + detail::IF< + is_pointer_A && is_pointer_B, + detail::return_type_deduction_failure< + detail::illegal_pointer_arithmetic + >, + typename detail::IF<is_pointer_A, AP, BP>::RET + >::RET type; + +}; + +template<class A, class B> +struct pointer_arithmetic_traits<minus_action, A, B> { + typedef typename + array_to_pointer<typename boost::remove_reference<A>::type>::type AP; + typedef typename + array_to_pointer<typename boost::remove_reference<B>::type>::type BP; + + static const bool is_pointer_A = boost::is_pointer<AP>::value; + static const bool is_pointer_B = boost::is_pointer<BP>::value; + + static const bool value = is_pointer_A || is_pointer_B; + + static const bool same_pointer_type = + is_pointer_A && is_pointer_B && + boost::is_same< + typename boost::remove_const< + typename boost::remove_pointer< + typename boost::remove_const<AP>::type + >::type + >::type, + typename boost::remove_const< + typename boost::remove_pointer< + typename boost::remove_const<BP>::type + >::type + >::type + >::value; + + // ptr - ptr has type ptrdiff_t + // note, that we do not check if, in ptr - B, B is + // valid for subtraction with a pointer. + // the compiler will catch it in the apply function + + typedef typename + detail::IF< + same_pointer_type, const std::ptrdiff_t, + typename detail::IF< + is_pointer_A, + AP, + detail::return_type_deduction_failure<detail::illegal_pointer_arithmetic> + >::RET + >::RET type; +}; + +} // namespace detail + +// -- arithmetic actions --------------------------------------------- + +namespace detail { + +template<bool is_pointer_arithmetic, class Act, class A, class B> +struct return_type_2_arithmetic_phase_1; + +template<class A, class B> struct return_type_2_arithmetic_phase_2; +template<class A, class B> struct return_type_2_arithmetic_phase_3; + +} // namespace detail + + +// drop any qualifiers from the argument types within arithmetic_action +template<class A, class B, class Act> +struct return_type_2<arithmetic_action<Act>, A, B> +{ + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter the whole arithmetic deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::return_type_2_arithmetic_phase_1< + detail::pointer_arithmetic_traits<Act, A, B>::value, Act, A, B + >, + plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B> + >::type type; +}; + +namespace detail { + +// perform integral promotion, no pointer arithmetic +template<bool is_pointer_arithmetic, class Act, class A, class B> +struct return_type_2_arithmetic_phase_1 +{ + typedef typename + return_type_2_arithmetic_phase_2< + typename remove_reference_and_cv<A>::type, + typename remove_reference_and_cv<B>::type + >::type type; +}; + +// pointer_arithmetic +template<class Act, class A, class B> +struct return_type_2_arithmetic_phase_1<true, Act, A, B> +{ + typedef typename + pointer_arithmetic_traits<Act, A, B>::type type; +}; + +template<class A, class B> +struct return_type_2_arithmetic_phase_2 { + typedef typename + return_type_2_arithmetic_phase_3< + typename promote_to_int<A>::type, + typename promote_to_int<B>::type + >::type type; +}; + +// specialization for unsigned int. +// We only have to do these two specialization because the value promotion will +// take care of the other cases. +// The unsigned int promotion rule is this: +// unsigned int to long if a long can hold all values of unsigned int, +// otherwise go to unsigned long. + +// struct so I don't have to type this twice. +struct promotion_of_unsigned_int +{ + typedef + detail::IF<sizeof(long) <= sizeof(unsigned int), + unsigned long, + long>::RET type; +}; + +template<> +struct return_type_2_arithmetic_phase_2<unsigned int, long> +{ + typedef promotion_of_unsigned_int::type type; +}; +template<> +struct return_type_2_arithmetic_phase_2<long, unsigned int> +{ + typedef promotion_of_unsigned_int::type type; +}; + + +template<class A, class B> struct return_type_2_arithmetic_phase_3 { + enum { promote_code_A_value = promote_code<A>::value, + promote_code_B_value = promote_code<B>::value }; // enums for KCC + typedef typename + detail::IF< + promote_code_A_value == -1 || promote_code_B_value == -1, + detail::return_type_deduction_failure<return_type_2_arithmetic_phase_3>, + typename detail::IF< + ((int)promote_code_A_value > (int)promote_code_B_value), + A, + B + >::RET + >::RET type; +}; + +} // namespace detail + +// -- bitwise actions ------------------------------------------- +// note: for integral types deuduction is similar to arithmetic actions. + +// drop any qualifiers from the argument types within arithmetic action +template<class A, class B, class Act> +struct return_type_2<bitwise_action<Act>, A, B> +{ + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<bitwise_action<Act>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter type deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + return_type_2<arithmetic_action<plus_action>, A, B>, + plain_return_type_2<bitwise_action<Act>, plain_A, plain_B> + >::type type; + + // plus_action is just a random pick, has to be a concrete instance + + // TODO: This check is only valid for built-in types, overloaded types might + // accept floating point operators + + // bitwise operators not defined for floating point types + // these test are not strictly needed here, since the error will be caught in + // the apply function + BOOST_STATIC_ASSERT(!(boost::is_float<plain_A>::value && boost::is_float<plain_B>::value)); + +}; + +namespace detail { + +#ifdef BOOST_NO_TEMPLATED_STREAMS + +template<class A, class B> +struct leftshift_type { + + typedef typename detail::IF< + boost::is_convertible< + typename boost::remove_reference<A>::type*, + std::ostream* + >::value, + std::ostream&, + typename detail::remove_reference_and_cv<A>::type + >::RET type; +}; + +template<class A, class B> +struct rightshift_type { + + typedef typename detail::IF< + + boost::is_convertible< + typename boost::remove_reference<A>::type*, + std::istream* + >::value, + std::istream&, + typename detail::remove_reference_and_cv<A>::type + >::RET type; +}; + +#else + +template <class T> struct get_ostream_type { + typedef std::basic_ostream<typename T::char_type, + typename T::traits_type>& type; +}; + +template <class T> struct get_istream_type { + typedef std::basic_istream<typename T::char_type, + typename T::traits_type>& type; +}; + +template<class A, class B> +struct leftshift_type { +private: + typedef typename boost::remove_reference<A>::type plainA; +public: + typedef typename detail::IF_type< + is_instance_of_2<plainA, std::basic_ostream>::value, + get_ostream_type<plainA>, //reference to the stream + detail::remove_reference_and_cv<A> + >::type type; +}; + +template<class A, class B> +struct rightshift_type { +private: + typedef typename boost::remove_reference<A>::type plainA; +public: + typedef typename detail::IF_type< + is_instance_of_2<plainA, std::basic_istream>::value, + get_istream_type<plainA>, //reference to the stream + detail::remove_reference_and_cv<A> + >::type type; +}; + + +#endif + +} // end detail + +// ostream +template<class A, class B> +struct return_type_2<bitwise_action<leftshift_action>, A, B> +{ + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter type deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::leftshift_type<A, B>, + plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B> + >::type type; +}; + +// istream +template<class A, class B> +struct return_type_2<bitwise_action<rightshift_action>, A, B> +{ + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter type deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::rightshift_type<A, B>, + plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B> + >::type type; +}; + +// -- logical actions ---------------------------------------- +// always bool +// NOTE: this may not be true for some weird user-defined types, +template<class A, class B, class Act> +struct plain_return_type_2<logical_action<Act>, A, B> { + typedef bool type; +}; + +template<class A, class B, class Act> +struct return_type_2<logical_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<logical_action<Act>, plain_A, plain_B>::type type; + +}; + + +// -- relational actions ---------------------------------------- +// always bool +// NOTE: this may not be true for some weird user-defined types, +template<class A, class B, class Act> +struct plain_return_type_2<relational_action<Act>, A, B> { + typedef bool type; +}; + +template<class A, class B, class Act> +struct return_type_2<relational_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<relational_action<Act>, plain_A, plain_B>::type type; +}; + +// Assingment actions ----------------------------------------------- +// return type is the type of the first argument as reference + +// note that cv-qualifiers are preserved. +// Yes, assignment operator can be const! + +// NOTE: this may not be true for some weird user-defined types, + +template<class A, class B, class Act> +struct return_type_2<arithmetic_assignment_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + arithmetic_assignment_action<Act>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::add_reference<A>::type, + type1 + >::RET type; +}; + +template<class A, class B, class Act> +struct return_type_2<bitwise_assignment_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + bitwise_assignment_action<Act>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::add_reference<A>::type, + type1 + >::RET type; +}; + +template<class A, class B> +struct return_type_2<other_action<assignment_action>, A, B> { + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + other_action<assignment_action>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::add_reference<A>::type, + type1 + >::RET type; +}; + +// -- other actions ---------------------------------------- + +// comma action ---------------------------------- +// Note: this may not be true for some weird user-defined types, + +// NOTE! This only tries the plain_return_type_2 layer and gives +// detail::unspecified as default. If no such specialization is found, the +// type rule in the spcecialization of the return_type_2_prot is used +// to give the type of the right argument (which can be a reference too) +// (The built in operator, can return a l- or rvalue). +template<class A, class B> +struct return_type_2<other_action<comma_action>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + other_action<comma_action>, plain_A, plain_B + >::type type; + }; + +// subscript action ----------------------------------------------- + + +namespace detail { + // A and B are nonreference types +template <class A, class B> struct subscript_type { + typedef detail::unspecified type; +}; + +template <class A, class B> struct subscript_type<A*, B> { + typedef A& type; +}; +template <class A, class B> struct subscript_type<A* const, B> { + typedef A& type; +}; +template <class A, class B> struct subscript_type<A* volatile, B> { + typedef A& type; +}; +template <class A, class B> struct subscript_type<A* const volatile, B> { + typedef A& type; +}; + + +template<class A, class B, int N> struct subscript_type<A[N], B> { + typedef A& type; +}; + + // these 3 specializations are needed to make gcc <3 happy +template<class A, class B, int N> struct subscript_type<const A[N], B> { + typedef const A& type; +}; +template<class A, class B, int N> struct subscript_type<volatile A[N], B> { + typedef volatile A& type; +}; +template<class A, class B, int N> struct subscript_type<const volatile A[N], B> { + typedef const volatile A& type; +}; + +} // end detail + +template<class A, class B> +struct return_type_2<other_action<subscript_action>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename boost::remove_reference<A>::type nonref_A; + typedef typename boost::remove_reference<B>::type nonref_B; + + typedef typename + plain_return_type_2< + other_action<subscript_action>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::subscript_type<nonref_A, nonref_B>, + plain_return_type_2<other_action<subscript_action>, plain_A, plain_B> + >::type type; + +}; + +template<class Key, class T, class Cmp, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::map<Key, T, Cmp, Allocator>, B> { + typedef T& type; + // T == std::map<Key, T, Cmp, Allocator>::mapped_type; +}; + +template<class Key, class T, class Cmp, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::multimap<Key, T, Cmp, Allocator>, B> { + typedef T& type; + // T == std::map<Key, T, Cmp, Allocator>::mapped_type; +}; + + // deque +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::deque<T, Allocator>, B> { + typedef typename std::deque<T, Allocator>::reference type; +}; +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, const std::deque<T, Allocator>, B> { + typedef typename std::deque<T, Allocator>::const_reference type; +}; + + // vector +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::vector<T, Allocator>, B> { + typedef typename std::vector<T, Allocator>::reference type; +}; +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, const std::vector<T, Allocator>, B> { + typedef typename std::vector<T, Allocator>::const_reference type; +}; + + // basic_string +template<class Char, class Traits, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::basic_string<Char, Traits, Allocator>, B> { + typedef typename std::basic_string<Char, Traits, Allocator>::reference type; +}; +template<class Char, class Traits, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, const std::basic_string<Char, Traits, Allocator>, B> { + typedef typename std::basic_string<Char, Traits, Allocator>::const_reference type; +}; + +template<class Char, class Traits, class Allocator> +struct plain_return_type_2<arithmetic_action<plus_action>, + std::basic_string<Char, Traits, Allocator>, + std::basic_string<Char, Traits, Allocator> > { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator> +struct plain_return_type_2<arithmetic_action<plus_action>, + const Char*, + std::basic_string<Char, Traits, Allocator> > { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator> +struct plain_return_type_2<arithmetic_action<plus_action>, + std::basic_string<Char, Traits, Allocator>, + const Char*> { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator, std::size_t N> +struct plain_return_type_2<arithmetic_action<plus_action>, + Char[N], + std::basic_string<Char, Traits, Allocator> > { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator, std::size_t N> +struct plain_return_type_2<arithmetic_action<plus_action>, + std::basic_string<Char, Traits, Allocator>, + Char[N]> { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + + +} // namespace lambda +} // namespace boost + +#endif + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/operators.hpp b/3rdParty/Boost/src/boost/lambda/detail/operators.hpp new file mode 100644 index 0000000..149e1ee --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/operators.hpp @@ -0,0 +1,370 @@ +// Boost Lambda Library - operators.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_OPERATORS_HPP +#define BOOST_LAMBDA_OPERATORS_HPP + +#include "boost/lambda/detail/is_instance_of.hpp" + +namespace boost { +namespace lambda { + +#if defined BOOST_LAMBDA_BE1 +#error "Multiple defines of BOOST_LAMBDA_BE1" +#endif + + // For all BOOSTA_LAMBDA_BE* macros: + + // CONSTA must be either 'A' or 'const A' + // CONSTB must be either 'B' or 'const B' + + // It is stupid to have the names A and B as macro arguments, but it avoids + // the need to pass in emtpy macro arguments, which gives warnings on some + // compilers + +#define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \ +template<class Arg, class B> \ +inline const \ +lambda_functor< \ + lambda_functor_base< \ + ACTION, \ + tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type> \ + > \ +> \ +OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) { \ + return \ + lambda_functor_base< \ + ACTION, \ + tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\ + > \ + (tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \ +} + + +#if defined BOOST_LAMBDA_BE2 +#error "Multiple defines of BOOST_LAMBDA_BE2" +#endif + +#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \ +template<class A, class Arg> \ +inline const \ +lambda_functor< \ + lambda_functor_base< \ + ACTION, \ + tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \ + > \ +> \ +OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) { \ + return \ + lambda_functor_base< \ + ACTION, \ + tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \ + > \ + (tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \ +} + + +#if defined BOOST_LAMBDA_BE3 +#error "Multiple defines of BOOST_LAMBDA_BE3" +#endif + +#define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \ +template<class ArgA, class ArgB> \ +inline const \ +lambda_functor< \ + lambda_functor_base< \ + ACTION, \ + tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \ + > \ +> \ +OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \ + return \ + lambda_functor_base< \ + ACTION, \ + tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \ + > \ + (tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b)); \ +} + +#if defined BOOST_LAMBDA_BE +#error "Multiple defines of BOOST_LAMBDA_BE" +#endif + +#define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \ +BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \ +BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \ +BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) + +#define BOOST_LAMBDA_EMPTY() + +BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument) + +BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument) +BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument) + + +// A special trick for comma operator for correct preprocessing +#if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME +#error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME" +#endif + +#define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator, + +BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument) +BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument) + + + +namespace detail { + +// special cases for ostream& << Any and istream& >> Any --------------- +// the actual stream classes may vary and thus a specialisation for, +// say ostream& does not match (the general case above is chosen). +// Therefore we specialise for non-const reference: +// if the left argument is a stream, we store the stream as reference +// if it is something else, we store a const plain by default + +// Note that the overloading is const vs. non-const first argument + +#ifdef BOOST_NO_TEMPLATED_STREAMS +template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default { + typedef typename detail::IF< + boost::is_convertible<T*, std::ostream*>::value, + T&, + typename const_copy_argument <T>::type + >::RET type; +}; + +template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default { + typedef typename detail::IF< + boost::is_convertible<T*, std::istream*>::value, + T&, + typename const_copy_argument <T>::type + >::RET type; +}; +#else + +template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default { + typedef typename detail::IF< + is_instance_of_2< + T, std::basic_ostream + >::value, + T&, + typename const_copy_argument <T>::type + >::RET type; +}; + +template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default { + typedef typename detail::IF< + is_instance_of_2< + T, std::basic_istream + >::value, + T&, + typename const_copy_argument <T>::type + >::RET type; +}; +#endif + +} // detail + +BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default) +BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default) + + +// special case for io_manipulators. +// function references cannot be given as arguments to lambda operator +// expressions in general. With << and >> the use of manipulators is +// so common, that specializations are provided to make them work. + +template<class Arg, class Ret, class ManipArg> +inline const +lambda_functor< + lambda_functor_base< + bitwise_action<leftshift_action>, + tuple<lambda_functor<Arg>, Ret(&)(ManipArg)> + > +> +operator<<(const lambda_functor<Arg>& a, Ret(&b)(ManipArg)) +{ + return + lambda_functor_base< + bitwise_action<leftshift_action>, + tuple<lambda_functor<Arg>, Ret(&)(ManipArg)> + > + ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) ); +} + +template<class Arg, class Ret, class ManipArg> +inline const +lambda_functor< + lambda_functor_base< + bitwise_action<rightshift_action>, + tuple<lambda_functor<Arg>, Ret(&)(ManipArg)> + > +> +operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg)) +{ + return + lambda_functor_base< + bitwise_action<rightshift_action>, + tuple<lambda_functor<Arg>, Ret(&)(ManipArg)> + > + ( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) ); +} + + +// (+ and -) take their arguments as const references. +// This has consquences with pointer artihmetic +// E.g int a[]; ... *a = 1 works but not *(a+1) = 1. +// the result of a+1 would be const +// To make the latter work too, +// non-const arrays are taken as non-const and stored as non-const as well. +#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E1 +#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E1" +#endif + +#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB) \ +template<class Arg, int N, class B> \ +inline const \ +lambda_functor< \ + lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \ +> \ +OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N]) \ +{ \ + return \ + lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \ + (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b)); \ +} + + +#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E2 +#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E2" +#endif + +#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA) \ +template<int N, class A, class Arg> \ +inline const \ +lambda_functor< \ + lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \ +> \ +OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b) \ +{ \ + return \ + lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \ + (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b)); \ +} + + +BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B) +BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A) +BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B) +BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A) + + +//BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>) +// This is not needed, since the result of ptr-ptr is an rvalue anyway + +BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A) +BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A) + + +#undef BOOST_LAMBDA_BE1 +#undef BOOST_LAMBDA_BE2 +#undef BOOST_LAMBDA_BE3 +#undef BOOST_LAMBDA_BE +#undef BOOST_LAMBDA_COMMA_OPERATOR_NAME + +#undef BOOST_LAMBDA_PTR_ARITHMETIC_E1 +#undef BOOST_LAMBDA_PTR_ARITHMETIC_E2 + + +// --------------------------------------------------------------------- +// unary operators ----------------------------------------------------- +// --------------------------------------------------------------------- + +#if defined BOOST_LAMBDA_UE +#error "Multiple defines of BOOST_LAMBDA_UE" +#endif + +#define BOOST_LAMBDA_UE(OPER_NAME, ACTION) \ +template<class Arg> \ +inline const \ +lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \ +OPER_NAME (const lambda_functor<Arg>& a) \ +{ \ + return \ + lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \ + ( tuple<lambda_functor<Arg> >(a) ); \ +} + + +BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>) +BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>) +BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>) +BOOST_LAMBDA_UE(operator!, logical_action<not_action>) +BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>) +BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>) +BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>) +BOOST_LAMBDA_UE(operator&, other_action<addressof_action>) + +#if defined BOOST_LAMBDA_POSTFIX_UE +#error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE" +#endif + +#define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION) \ +template<class Arg> \ +inline const \ +lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \ +OPER_NAME (const lambda_functor<Arg>& a, int) \ +{ \ + return \ + lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \ + ( tuple<lambda_functor<Arg> >(a) ); \ +} + + +BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>) +BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>) + +#undef BOOST_LAMBDA_UE +#undef BOOST_LAMBDA_POSTFIX_UE + +} // namespace lambda +} // namespace boost + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/detail/ret.hpp b/3rdParty/Boost/src/boost/lambda/detail/ret.hpp new file mode 100644 index 0000000..fbd8b3a --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/ret.hpp @@ -0,0 +1,325 @@ +// Boost Lambda Library ret.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_RET_HPP +#define BOOST_LAMBDA_RET_HPP + +namespace boost { +namespace lambda { + + // TODO: + +// Add specializations for function references for ret, protect and unlambda +// e.g void foo(); unlambda(foo); fails, as it would add a const qualifier + // for a function type. + // on the other hand unlambda(*foo) does work + + +// -- ret ------------------------- +// the explicit return type template + + // TODO: It'd be nice to make ret a nop for other than lambda functors + // but causes an ambiguiyty with gcc (not with KCC), check what is the + // right interpretation. + + // // ret for others than lambda functors has no effect + // template <class U, class T> + // inline const T& ret(const T& t) { return t; } + + +template<class RET, class Arg> +inline const +lambda_functor< + lambda_functor_base< + explicit_return_type_action<RET>, + tuple<lambda_functor<Arg> > + > +> +ret(const lambda_functor<Arg>& a1) +{ + return + lambda_functor_base< + explicit_return_type_action<RET>, + tuple<lambda_functor<Arg> > + > + (tuple<lambda_functor<Arg> >(a1)); +} + +// protect ------------------ + + // protecting others than lambda functors has no effect +template <class T> +inline const T& protect(const T& t) { return t; } + +template<class Arg> +inline const +lambda_functor< + lambda_functor_base< + protect_action, + tuple<lambda_functor<Arg> > + > +> +protect(const lambda_functor<Arg>& a1) +{ + return + lambda_functor_base< + protect_action, + tuple<lambda_functor<Arg> > + > + (tuple<lambda_functor<Arg> >(a1)); +} + +// ------------------------------------------------------------------- + +// Hides the lambda functorness of a lambda functor. +// After this, the functor is immune to argument substitution, etc. +// This can be used, e.g. to make it safe to pass lambda functors as +// arguments to functions, which might use them as target functions + +// note, unlambda and protect are different things. Protect hides the lambda +// functor for one application, unlambda for good. + +template <class LambdaFunctor> +class non_lambda_functor +{ + LambdaFunctor lf; +public: + + // This functor defines the result_type typedef. + // The result type must be deducible without knowing the arguments + + template <class SigArgs> struct sig { + typedef typename + LambdaFunctor::inherited:: + template sig<typename SigArgs::tail_type>::type type; + }; + + explicit non_lambda_functor(const LambdaFunctor& a) : lf(a) {} + + typename LambdaFunctor::nullary_return_type + operator()() const { + return lf.template + call<typename LambdaFunctor::nullary_return_type> + (cnull_type(), cnull_type(), cnull_type(), cnull_type()); + } + + template<class A> + typename sig<tuple<const non_lambda_functor, A&> >::type + operator()(A& a) const { + return lf.template call<typename sig<tuple<const non_lambda_functor, A&> >::type >(a, cnull_type(), cnull_type(), cnull_type()); + } + + template<class A, class B> + typename sig<tuple<const non_lambda_functor, A&, B&> >::type + operator()(A& a, B& b) const { + return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&> >::type >(a, b, cnull_type(), cnull_type()); + } + + template<class A, class B, class C> + typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type + operator()(A& a, B& b, C& c) const { + return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type>(a, b, c, cnull_type()); + } +}; + +template <class Arg> +inline const Arg& unlambda(const Arg& a) { return a; } + +template <class Arg> +inline const non_lambda_functor<lambda_functor<Arg> > +unlambda(const lambda_functor<Arg>& a) +{ + return non_lambda_functor<lambda_functor<Arg> >(a); +} + + // Due to a language restriction, lambda functors cannot be made to + // accept non-const rvalue arguments. Usually iterators do not return + // temporaries, but sometimes they do. That's why a workaround is provided. + // Note, that this potentially breaks const correctness, so be careful! + +// any lambda functor can be turned into a const_incorrect_lambda_functor +// The operator() takes arguments as consts and then casts constness +// away. So this breaks const correctness!!! but is a necessary workaround +// in some cases due to language limitations. +// Note, that this is not a lambda_functor anymore, so it can not be used +// as a sub lambda expression. + +template <class LambdaFunctor> +struct const_incorrect_lambda_functor { + LambdaFunctor lf; +public: + + explicit const_incorrect_lambda_functor(const LambdaFunctor& a) : lf(a) {} + + template <class SigArgs> struct sig { + typedef typename + LambdaFunctor::inherited::template + sig<typename SigArgs::tail_type>::type type; + }; + + // The nullary case is not needed (no arguments, no parameter type problems) + + template<class A> + typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type + operator()(const A& a) const { + return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type >(const_cast<A&>(a), cnull_type(), cnull_type(), cnull_type()); + } + + template<class A, class B> + typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type + operator()(const A& a, const B& b) const { + return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type >(const_cast<A&>(a), const_cast<B&>(b), cnull_type(), cnull_type()); + } + + template<class A, class B, class C> + typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type + operator()(const A& a, const B& b, const C& c) const { + return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type>(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c), cnull_type()); + } +}; + +// ------------------------------------------------------------------------ +// any lambda functor can be turned into a const_parameter_lambda_functor +// The operator() takes arguments as const. +// This is useful if lambda functors are called with non-const rvalues. +// Note, that this is not a lambda_functor anymore, so it can not be used +// as a sub lambda expression. + +template <class LambdaFunctor> +struct const_parameter_lambda_functor { + LambdaFunctor lf; +public: + + explicit const_parameter_lambda_functor(const LambdaFunctor& a) : lf(a) {} + + template <class SigArgs> struct sig { + typedef typename + LambdaFunctor::inherited::template + sig<typename SigArgs::tail_type>::type type; + }; + + // The nullary case is not needed: no arguments, no constness problems. + + template<class A> + typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type + operator()(const A& a) const { + return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type >(a, cnull_type(), cnull_type(), cnull_type()); + } + + template<class A, class B> + typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type + operator()(const A& a, const B& b) const { + return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type >(a, b, cnull_type(), cnull_type()); + } + + template<class A, class B, class C> + typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&> +>::type + operator()(const A& a, const B& b, const C& c) const { + return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&> >::type>(a, b, c, cnull_type()); + } +}; + +template <class Arg> +inline const const_incorrect_lambda_functor<lambda_functor<Arg> > +break_const(const lambda_functor<Arg>& lf) +{ + return const_incorrect_lambda_functor<lambda_functor<Arg> >(lf); +} + + +template <class Arg> +inline const const_parameter_lambda_functor<lambda_functor<Arg> > +const_parameters(const lambda_functor<Arg>& lf) +{ + return const_parameter_lambda_functor<lambda_functor<Arg> >(lf); +} + +// make void ------------------------------------------------ +// make_void( x ) turns a lambda functor x with some return type y into +// another lambda functor, which has a void return type +// when called, the original return type is discarded + +// we use this action. The action class will be called, which means that +// the wrapped lambda functor is evaluated, but we just don't do anything +// with the result. +struct voidifier_action { + template<class Ret, class A> static void apply(A&) {} +}; + +template<class Args> struct return_type_N<voidifier_action, Args> { + typedef void type; +}; + +template<class Arg1> +inline const +lambda_functor< + lambda_functor_base< + action<1, voidifier_action>, + tuple<lambda_functor<Arg1> > + > +> +make_void(const lambda_functor<Arg1>& a1) { +return + lambda_functor_base< + action<1, voidifier_action>, + tuple<lambda_functor<Arg1> > + > + (tuple<lambda_functor<Arg1> > (a1)); +} + +// for non-lambda functors, make_void does nothing +// (the argument gets evaluated immediately) + +template<class Arg1> +inline const +lambda_functor< + lambda_functor_base<do_nothing_action, null_type> +> +make_void(const Arg1& a1) { +return + lambda_functor_base<do_nothing_action, null_type>(); +} + +// std_functor ----------------------------------------------------- + +// The STL uses the result_type typedef as the convention to let binders know +// the return type of a function object. +// LL uses the sig template. +// To let LL know that the function object has the result_type typedef +// defined, it can be wrapped with the std_functor function. + + +// Just inherit form the template parameter (the standard functor), +// and provide a sig template. So we have a class which is still the +// same functor + the sig template. + +template<class T> +struct result_type_to_sig : public T { + template<class Args> struct sig { typedef typename T::result_type type; }; + result_type_to_sig(const T& t) : T(t) {} +}; + +template<class F> +inline result_type_to_sig<F> std_functor(const F& f) { return f; } + + +} // namespace lambda +} // namespace boost + +#endif + + + + + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/return_type_traits.hpp b/3rdParty/Boost/src/boost/lambda/detail/return_type_traits.hpp new file mode 100644 index 0000000..bf2394e --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/return_type_traits.hpp @@ -0,0 +1,282 @@ +// return_type_traits.hpp -- Boost Lambda Library --------------------------- + +// 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_RETURN_TYPE_TRAITS_HPP +#define BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP + +#include "boost/mpl/has_xxx.hpp" + +#include <cstddef> // needed for the ptrdiff_t + +namespace boost { +namespace lambda { + +using ::boost::type_traits::ice_and; +using ::boost::type_traits::ice_or; +using ::boost::type_traits::ice_not; + +// Much of the type deduction code for standard arithmetic types +// from Gary Powell + + // different arities: +template <class Act, class A1> struct return_type_1; // 1-ary actions +template <class Act, class A1, class A2> struct return_type_2; // 2-ary +template <class Act, class Args> struct return_type_N; // >3- ary + +template <class Act, class A1> struct return_type_1_prot; +template <class Act, class A1, class A2> struct return_type_2_prot; // 2-ary +template <class Act, class A1> struct return_type_N_prot; // >3-ary + + +namespace detail { + +template<class> class return_type_deduction_failure {}; + + // In some cases return type deduction should fail (an invalid lambda + // expression). Sometimes the lambda expression can be ok, the return type + // just is not deducible (user defined operators). Then return type deduction + // should never be entered at all, and the use of ret<> does this. + // However, for nullary lambda functors, return type deduction is always + // entered, and there seems to be no way around this. + + // (the return type is part of the prototype of the non-template + // operator()(). The prototype is instantiated, even though the body + // is not.) + + // So, in the case the return type deduction should fail, it should not + // fail directly, but rather result in a valid but wrong return type, + // causing a compile time error only if the function is really called. + + + +} // end detail + + + +// return_type_X_prot classes -------------------------------------------- +// These classes are the first layer that gets instantiated from the +// lambda_functor_base sig templates. It will check whether +// the action is protectable and one of arguments is "protected" or its +// evaluation will otherwise result in another lambda functor. +// If this is a case, the result type will be another lambda functor. + +// The arguments are always non-reference types, except for comma action +// where the right argument can be a reference too. This is because it +// matters (in the builtin case) whether the argument is an lvalue or +// rvalue: int i; i, 1 -> rvalue; 1, i -> lvalue + +template <class Act, class A> struct return_type_1_prot { +public: + typedef typename + detail::IF< + // is_protectable<Act>::value && is_lambda_functor<A>::value, + ice_and<is_protectable<Act>::value, is_lambda_functor<A>::value>::value, + lambda_functor< + lambda_functor_base< + Act, + tuple<typename detail::remove_reference_and_cv<A>::type> + > + >, + typename return_type_1<Act, A>::type + >::RET type; +}; + + // take care of the unavoidable instantiation for nullary case +template<class Act> struct return_type_1_prot<Act, null_type> { + typedef null_type type; +}; + +// Unary actions (result from unary operators) +// do not have a default return type. +template<class Act, class A> struct return_type_1 { + typedef typename + detail::return_type_deduction_failure<return_type_1> type; +}; + + +namespace detail { + + template <class T> + class protect_conversion { + typedef typename boost::remove_reference<T>::type non_ref_T; + public: + + // add const to rvalues, so that all rvalues are stored as const in + // the args tuple + typedef typename detail::IF_type< +// boost::is_reference<T>::value && !boost::is_const<non_ref_T>::value, + ice_and<boost::is_reference<T>::value, + ice_not<boost::is_const<non_ref_T>::value>::value>::value, + detail::identity_mapping<T>, + const_copy_argument<non_ref_T> // handles funtion and array + >::type type; // types correctly + }; + +} // end detail + +template <class Act, class A, class B> struct return_type_2_prot { + +// experimental feature + // We may have a lambda functor as a result type of a subexpression + // (if protect) has been used. + // Thus, if one of the parameter types is a lambda functor, the result + // is a lambda functor as well. + // We need to make a conservative choise here. + // The resulting lambda functor stores all const reference arguments as + // const copies. References to non-const are stored as such. + // So if the source of the argument is a const open argument, a bound + // argument stored as a const reference, or a function returning a + // const reference, that information is lost. There is no way of + // telling apart 'real const references' from just 'LL internal + // const references' (or it would be really hard) + + // The return type is a subclass of lambda_functor, which has a converting + // copy constructor. It can copy any lambda functor, that has the same + // action type and code, and a copy compatible argument tuple. + + + typedef typename boost::remove_reference<A>::type non_ref_A; + typedef typename boost::remove_reference<B>::type non_ref_B; + +typedef typename + detail::IF< +// is_protectable<Act>::value && +// (is_lambda_functor<A>::value || is_lambda_functor<B>::value), + ice_and<is_protectable<Act>::value, + ice_or<is_lambda_functor<A>::value, + is_lambda_functor<B>::value>::value>::value, + lambda_functor< + lambda_functor_base< + Act, + tuple<typename detail::protect_conversion<A>::type, + typename detail::protect_conversion<B>::type> + > + >, + typename return_type_2<Act, non_ref_A, non_ref_B>::type + >::RET type; +}; + + // take care of the unavoidable instantiation for nullary case +template<class Act> struct return_type_2_prot<Act, null_type, null_type> { + typedef null_type type; +}; + // take care of the unavoidable instantiation for nullary case +template<class Act, class Other> struct return_type_2_prot<Act, Other, null_type> { + typedef null_type type; +}; + // take care of the unavoidable instantiation for nullary case +template<class Act, class Other> struct return_type_2_prot<Act, null_type, Other> { + typedef null_type type; +}; + + // comma is a special case, as the user defined operator can return + // an lvalue (reference) too, hence it must be handled at this level. +template<class A, class B> +struct return_type_2_comma +{ + typedef typename boost::remove_reference<A>::type non_ref_A; + typedef typename boost::remove_reference<B>::type non_ref_B; + +typedef typename + detail::IF< +// is_protectable<other_action<comma_action> >::value && // it is protectable +// (is_lambda_functor<A>::value || is_lambda_functor<B>::value), + ice_and<is_protectable<other_action<comma_action> >::value, // it is protectable + ice_or<is_lambda_functor<A>::value, + is_lambda_functor<B>::value>::value>::value, + lambda_functor< + lambda_functor_base< + other_action<comma_action>, + tuple<typename detail::protect_conversion<A>::type, + typename detail::protect_conversion<B>::type> + > + >, + typename + return_type_2<other_action<comma_action>, non_ref_A, non_ref_B>::type + >::RET type1; + + // if no user defined return_type_2 (or plain_return_type_2) specialization + // matches, then return the righthand argument + typedef typename + detail::IF< + boost::is_same<type1, detail::unspecified>::value, + B, + type1 + >::RET type; + +}; + + + // currently there are no protectable actions with > 2 args + +template<class Act, class Args> struct return_type_N_prot { + typedef typename return_type_N<Act, Args>::type type; +}; + + // take care of the unavoidable instantiation for nullary case +template<class Act> struct return_type_N_prot<Act, null_type> { + typedef null_type type; +}; + +// handle different kind of actions ------------------------ + + // use the return type given in the bind invocation as bind<Ret>(...) +template<int I, class Args, class Ret> +struct return_type_N<function_action<I, Ret>, Args> { + typedef Ret type; +}; + +// ::result_type support + +namespace detail +{ + +BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type) + +template<class F> struct get_result_type +{ + typedef typename F::result_type type; +}; + +template<class F, class A> struct get_sig +{ + typedef typename function_adaptor<F>::template sig<A>::type type; +}; + +} // namespace detail + + // Ret is detail::unspecified, so try to deduce return type +template<int I, class Args> +struct return_type_N<function_action<I, detail::unspecified>, Args > { + + // in the case of function action, the first element in Args is + // some type of function + typedef typename Args::head_type Func; + typedef typename detail::remove_reference_and_cv<Func>::type plain_Func; + +public: + // pass the function to function_adaptor, and get the return type from + // that + typedef typename detail::IF< + detail::has_result_type<plain_Func>::value, + detail::get_result_type<plain_Func>, + detail::get_sig<plain_Func, Args> + >::RET::type type; +}; + + +} // namespace lambda +} // namespace boost + +#endif + + + diff --git a/3rdParty/Boost/src/boost/lambda/detail/select_functions.hpp b/3rdParty/Boost/src/boost/lambda/detail/select_functions.hpp new file mode 100644 index 0000000..956045c --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/select_functions.hpp @@ -0,0 +1,74 @@ +// -- select_functions.hpp -- Boost Lambda Library -------------------------- + +// 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 http://www.boost.org + + +#ifndef BOOST_LAMBDA_SELECT_FUNCTIONS_HPP +#define BOOST_LAMBDA_SELECT_FUNCTIONS_HPP + +namespace boost { +namespace lambda { +namespace detail { + + +// select functions ------------------------------- +template<class Any, CALL_TEMPLATE_ARGS> +inline Any& select(Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; } + + +template<class Arg, CALL_TEMPLATE_ARGS> +inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type +select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { + return op.template call< + typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type + >(CALL_ACTUAL_ARGS); +} +template<class Arg, CALL_TEMPLATE_ARGS> +inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type +select ( lambda_functor<Arg>& op, CALL_FORMAL_ARGS) { + return op.template call< + typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type + >(CALL_ACTUAL_ARGS); +} + +// ------------------------------------------------------------------------ +// select functions where the return type is explicitly given +// Note: on many functions, this return type is just discarded. +// The select functions are inside a class template, and the return type +// is a class template argument. +// The first implementation used function templates with an explicitly +// specified template parameter. +// However, this resulted in ambiguous calls (at least with gcc 2.95.2 +// and edg 2.44). Not sure whether the compilers were right or wrong. + +template<class RET> struct r_select { + +// Any == RET + template<class Any, CALL_TEMPLATE_ARGS> + static + inline RET go (Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; } + + + template<class Arg, CALL_TEMPLATE_ARGS> + static + inline RET go (const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { + return op.template call<RET>(CALL_ACTUAL_ARGS); + } + template<class Arg, CALL_TEMPLATE_ARGS> + static + inline RET go (lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) { + return op.template call<RET>(CALL_ACTUAL_ARGS); + } +}; + +} // namespace detail +} // namespace lambda +} // namespace boost + +#endif diff --git a/3rdParty/Boost/src/boost/lambda/lambda.hpp b/3rdParty/Boost/src/boost/lambda/lambda.hpp new file mode 100644 index 0000000..75b06c7 --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/lambda.hpp @@ -0,0 +1,34 @@ +// -- lambda.hpp -- Boost Lambda Library ----------------------------------- +// 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 http://lambda.cs.utu.fi + +#ifndef BOOST_LAMBDA_LAMBDA_HPP +#define BOOST_LAMBDA_LAMBDA_HPP + + +#include "boost/lambda/core.hpp" + +#ifdef BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS +#include <istream> +#include <ostream> +#endif + +#include "boost/lambda/detail/operator_actions.hpp" +#include "boost/lambda/detail/operator_lambda_func_base.hpp" +#include "boost/lambda/detail/operator_return_type_traits.hpp" + + +#include "boost/lambda/detail/operators.hpp" + +#ifndef BOOST_LAMBDA_FAILS_IN_TEMPLATE_KEYWORD_AFTER_SCOPE_OPER +// sorry, member ptr does not work with gcc2.95 +#include "boost/lambda/detail/member_ptr.hpp" +#endif + + +#endif |