diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/lambda/if.hpp')
| -rw-r--r-- | src/third_party/boost-1.56.0/boost/lambda/if.hpp | 462 |
1 files changed, 0 insertions, 462 deletions
diff --git a/src/third_party/boost-1.56.0/boost/lambda/if.hpp b/src/third_party/boost-1.56.0/boost/lambda/if.hpp deleted file mode 100644 index 08f45f984a3..00000000000 --- a/src/third_party/boost-1.56.0/boost/lambda/if.hpp +++ /dev/null @@ -1,462 +0,0 @@ -// Boost Lambda Library -- if.hpp ------------------------------------------ - -// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) -// Copyright (C) 2000 Gary Powell (powellg@amazon.com) -// Copyright (C) 2001-2002 Joel de Guzman -// -// 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_IF_HPP) -#define BOOST_LAMBDA_IF_HPP - -#include "boost/lambda/core.hpp" - -// Arithmetic type promotion needed for if_then_else_return -#include "boost/lambda/detail/operator_actions.hpp" -#include "boost/lambda/detail/operator_return_type_traits.hpp" - -namespace boost { -namespace lambda { - -// -- if control construct actions ---------------------- - -class ifthen_action {}; -class ifthenelse_action {}; -class ifthenelsereturn_action {}; - -// Specialization for if_then. -template<class Args> -class -lambda_functor_base<ifthen_action, Args> { -public: - Args args; - template <class T> struct sig { typedef void type; }; -public: - explicit lambda_functor_base(const Args& a) : args(a) {} - - template<class RET, CALL_TEMPLATE_ARGS> - RET call(CALL_FORMAL_ARGS) const { - if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) - detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); - } -}; - -// If Then -template <class Arg1, class Arg2> -inline const -lambda_functor< - lambda_functor_base< - ifthen_action, - tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > - > -> -if_then(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) { - return - lambda_functor_base< - ifthen_action, - tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > - > - ( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2) ); -} - - -// Specialization for if_then_else. -template<class Args> -class -lambda_functor_base<ifthenelse_action, Args> { -public: - Args args; - template <class T> struct sig { typedef void type; }; -public: - explicit lambda_functor_base(const Args& a) : args(a) {} - - template<class RET, CALL_TEMPLATE_ARGS> - RET call(CALL_FORMAL_ARGS) const { - if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) - detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); - else - detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS); - } -}; - - - -// If then else - -template <class Arg1, class Arg2, class Arg3> -inline const -lambda_functor< - lambda_functor_base< - ifthenelse_action, - tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> > - > -> -if_then_else(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2, - const lambda_functor<Arg3>& a3) { - return - lambda_functor_base< - ifthenelse_action, - tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> > - > - (tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> > - (a1, a2, a3) ); -} - -// Our version of operator?:() - -template <class Arg1, class Arg2, class Arg3> -inline const - lambda_functor< - lambda_functor_base< - other_action<ifthenelsereturn_action>, - tuple<lambda_functor<Arg1>, - typename const_copy_argument<Arg2>::type, - typename const_copy_argument<Arg3>::type> - > -> -if_then_else_return(const lambda_functor<Arg1>& a1, - const Arg2 & a2, - const Arg3 & a3) { - return - lambda_functor_base< - other_action<ifthenelsereturn_action>, - tuple<lambda_functor<Arg1>, - typename const_copy_argument<Arg2>::type, - typename const_copy_argument<Arg3>::type> - > ( tuple<lambda_functor<Arg1>, - typename const_copy_argument<Arg2>::type, - typename const_copy_argument<Arg3>::type> (a1, a2, a3) ); -} - -namespace detail { - -// return type specialization for conditional expression begins ----------- -// start reading below and move upwards - -// PHASE 6:1 -// check if A is conbertible to B and B to A -template<int Phase, bool AtoB, bool BtoA, bool SameType, class A, class B> -struct return_type_2_ifthenelsereturn; - -// if A can be converted to B and vice versa -> ambiguous -template<int Phase, class A, class B> -struct return_type_2_ifthenelsereturn<Phase, true, true, false, A, B> { - typedef - detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type; - // ambiguous type in conditional expression -}; -// if A can be converted to B and vice versa and are of same type -template<int Phase, class A, class B> -struct return_type_2_ifthenelsereturn<Phase, true, true, true, A, B> { - typedef A type; -}; - - -// A can be converted to B -template<int Phase, class A, class B> -struct return_type_2_ifthenelsereturn<Phase, true, false, false, A, B> { - typedef B type; -}; - -// B can be converted to A -template<int Phase, class A, class B> -struct return_type_2_ifthenelsereturn<Phase, false, true, false, A, B> { - typedef A type; -}; - -// neither can be converted. Then we drop the potential references, and -// try again -template<class A, class B> -struct return_type_2_ifthenelsereturn<1, false, false, false, A, B> { - // it is safe to add const, since the result will be an rvalue and thus - // const anyway. The const are needed eg. if the types - // are 'const int*' and 'void *'. The remaining type should be 'const void*' - typedef const typename boost::remove_reference<A>::type plainA; - typedef const typename boost::remove_reference<B>::type plainB; - // TODO: Add support for volatile ? - - typedef typename - return_type_2_ifthenelsereturn< - 2, - boost::is_convertible<plainA,plainB>::value, - boost::is_convertible<plainB,plainA>::value, - boost::is_same<plainA,plainB>::value, - plainA, - plainB>::type type; -}; - -// PHASE 6:2 -template<class A, class B> -struct return_type_2_ifthenelsereturn<2, false, false, false, A, B> { - typedef - detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type; - // types_do_not_match_in_conditional_expression -}; - - - -// PHASE 5: now we know that types are not arithmetic. -template<class A, class B> -struct non_numeric_types { - typedef typename - return_type_2_ifthenelsereturn< - 1, // phase 1 - is_convertible<A,B>::value, - is_convertible<B,A>::value, - is_same<A,B>::value, - A, - B>::type type; -}; - -// PHASE 4 : -// the base case covers arithmetic types with differing promote codes -// use the type deduction of arithmetic_actions -template<int CodeA, int CodeB, class A, class B> -struct arithmetic_or_not { - typedef typename - return_type_2<arithmetic_action<plus_action>, A, B>::type type; - // plus_action is just a random pick, has to be a concrete instance -}; - -// this case covers the case of artihmetic types with the same promote codes. -// non numeric deduction is used since e.g. integral promotion is not -// performed with operator ?: -template<int CodeA, class A, class B> -struct arithmetic_or_not<CodeA, CodeA, A, B> { - typedef typename non_numeric_types<A, B>::type type; -}; - -// if either A or B has promote code -1 it is not an arithmetic type -template<class A, class B> -struct arithmetic_or_not <-1, -1, A, B> { - typedef typename non_numeric_types<A, B>::type type; -}; -template<int CodeB, class A, class B> -struct arithmetic_or_not <-1, CodeB, A, B> { - typedef typename non_numeric_types<A, B>::type type; -}; -template<int CodeA, class A, class B> -struct arithmetic_or_not <CodeA, -1, A, B> { - typedef typename non_numeric_types<A, B>::type type; -}; - - - - -// PHASE 3 : Are the types same? -// No, check if they are arithmetic or not -template <class A, class B> -struct same_or_not { - typedef typename detail::remove_reference_and_cv<A>::type plainA; - typedef typename detail::remove_reference_and_cv<B>::type plainB; - - typedef typename - arithmetic_or_not< - detail::promote_code<plainA>::value, - detail::promote_code<plainB>::value, - A, - B>::type type; -}; -// Yes, clear. -template <class A> struct same_or_not<A, A> { - typedef A type; -}; - -} // detail - -// PHASE 2 : Perform first the potential array_to_pointer conversion -template<class A, class B> -struct return_type_2<other_action<ifthenelsereturn_action>, A, B> { - - typedef typename detail::array_to_pointer<A>::type A1; - typedef typename detail::array_to_pointer<B>::type B1; - - typedef typename - boost::add_const<typename detail::same_or_not<A1, B1>::type>::type type; -}; - -// PHASE 1 : Deduction is based on the second and third operand - - -// return type specialization for conditional expression ends ----------- - - -// Specialization of lambda_functor_base for if_then_else_return. -template<class Args> -class -lambda_functor_base<other_action<ifthenelsereturn_action>, Args> { -public: - Args args; - - template <class SigArgs> struct sig { - private: - typedef typename detail::nth_return_type_sig<1, Args, SigArgs>::type ret1; - typedef typename detail::nth_return_type_sig<2, Args, SigArgs>::type ret2; - public: - typedef typename return_type_2< - other_action<ifthenelsereturn_action>, ret1, ret2 - >::type type; - }; - -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) - : - detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS); - } -}; - - // The code below is from Joel de Guzman, some name changes etc. - // has been made. - -/////////////////////////////////////////////////////////////////////////////// -// -// if_then_else_composite -// -// This composite has two (2) forms: -// -// if_(condition) -// [ -// statement -// ] -// -// and -// -// if_(condition) -// [ -// true_statement -// ] -// .else_ -// [ -// false_statement -// ] -// -// where condition is an lambda_functor that evaluates to bool. If condition -// is true, the true_statement (again an lambda_functor) is executed -// otherwise, the false_statement (another lambda_functor) is executed. The -// result type of this is void. Note the trailing underscore after -// if_ and the leading dot and the trailing underscore before -// and after .else_. -// -/////////////////////////////////////////////////////////////////////////////// -template <typename CondT, typename ThenT, typename ElseT> -struct if_then_else_composite { - - typedef if_then_else_composite<CondT, ThenT, ElseT> self_t; - - template <class SigArgs> - struct sig { typedef void type; }; - - if_then_else_composite( - CondT const& cond_, - ThenT const& then_, - ElseT const& else__) - : cond(cond_), then(then_), else_(else__) {} - - template <class Ret, CALL_TEMPLATE_ARGS> - Ret call(CALL_FORMAL_ARGS) const - { - if (cond.internal_call(CALL_ACTUAL_ARGS)) - then.internal_call(CALL_ACTUAL_ARGS); - else - else_.internal_call(CALL_ACTUAL_ARGS); - } - - CondT cond; ThenT then; ElseT else_; // lambda_functors -}; - -////////////////////////////////// -template <typename CondT, typename ThenT> -struct else_gen { - - else_gen(CondT const& cond_, ThenT const& then_) - : cond(cond_), then(then_) {} - - template <typename ElseT> - lambda_functor<if_then_else_composite<CondT, ThenT, - typename as_lambda_functor<ElseT>::type> > - operator[](ElseT const& else_) - { - typedef if_then_else_composite<CondT, ThenT, - typename as_lambda_functor<ElseT>::type> - result; - - return result(cond, then, to_lambda_functor(else_)); - } - - CondT cond; ThenT then; -}; - -////////////////////////////////// -template <typename CondT, typename ThenT> -struct if_then_composite { - - template <class SigArgs> - struct sig { typedef void type; }; - - if_then_composite(CondT const& cond_, ThenT const& then_) - : cond(cond_), then(then_), else_(cond, then) {} - - template <class Ret, CALL_TEMPLATE_ARGS> - Ret call(CALL_FORMAL_ARGS) const - { - if (cond.internal_call(CALL_ACTUAL_ARGS)) - then.internal_call(CALL_ACTUAL_ARGS); - } - - CondT cond; ThenT then; // lambda_functors - else_gen<CondT, ThenT> else_; -}; - -////////////////////////////////// -template <typename CondT> -struct if_gen { - - if_gen(CondT const& cond_) - : cond(cond_) {} - - template <typename ThenT> - lambda_functor<if_then_composite< - typename as_lambda_functor<CondT>::type, - typename as_lambda_functor<ThenT>::type> > - operator[](ThenT const& then) const - { - typedef if_then_composite< - typename as_lambda_functor<CondT>::type, - typename as_lambda_functor<ThenT>::type> - result; - - return result( - to_lambda_functor(cond), - to_lambda_functor(then)); - } - - CondT cond; -}; - -////////////////////////////////// -template <typename CondT> -inline if_gen<CondT> -if_(CondT const& cond) -{ - return if_gen<CondT>(cond); -} - - - -} // lambda -} // boost - -#endif // BOOST_LAMBDA_IF_HPP - - |