diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/lambda/detail/ret.hpp')
| -rw-r--r-- | src/third_party/boost-1.56.0/boost/lambda/detail/ret.hpp | 325 |
1 files changed, 0 insertions, 325 deletions
diff --git a/src/third_party/boost-1.56.0/boost/lambda/detail/ret.hpp b/src/third_party/boost-1.56.0/boost/lambda/detail/ret.hpp deleted file mode 100644 index 96f5fc18bb6..00000000000 --- a/src/third_party/boost-1.56.0/boost/lambda/detail/ret.hpp +++ /dev/null @@ -1,325 +0,0 @@ -// 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&) { -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 - - - - - - - |