comparison DEPENDENCIES/generic/include/boost/lambda/detail/ret.hpp @ 16:2665513ce2d3

Add boost headers

+// Boost Lambda Library  ret.hpp -----------------------------------------
+
+// Copyright (C) 1999, 2000 Jaakko Jarvi ([e-mail])
+//
+// 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
+
+
+
+
+
+
+