Boost 1.42.0

[SVN r59432]

CMakeLists.txt

@@ -1,21 +0,0 @@
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    lambda
-)
-
-# Add a library target to the build system
-boost_library_project(
-  lambda
-  #  SRCDIRS 
-  TESTDIRS  test
-  HEADERS ${lib_headers}
-  #  DOCDIRS 
-  #  DESCRIPTION 
-  MODULARIZED 
-  #  AUTHORS 
-  #  MAINTAINERS 
-)
-
-

include/boost/lambda/detail/lambda_functor_base.hpp

@@ -270,6 +270,8 @@ 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; };

include/boost/lambda/detail/operator_return_type_traits.hpp

@@ -15,6 +15,7 @@
 #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
@@ -58,10 +59,6 @@ template <> struct promote_code<long double> { static const int value = 700; };
 } // namespace lambda 
 } // namespace boost
 
-namespace std {
-  template<class T> class complex;
-}
-
 namespace boost { 
 namespace lambda {
 namespace detail {
@@ -228,37 +225,15 @@ template <> struct contentsof_type<null_type> {
 
 
 template <class A> struct contentsof_type<const A> {
-  typedef typename contentsof_type<A>::type type1;
-  // return a reference to the underlying const type
-  // the IF is because the A::reference in the primary template could
-  // be some class type rather than a real reference, hence
-  // we do not want to make it a reference here either
-  typedef typename boost::remove_reference<type1>::type no_reference;
-  typedef typename detail::IF<
-      is_reference<type1>::value, 
-      const no_reference &,
-      const no_reference
-  >::RET type;
+  typedef typename contentsof_type<A>::type type;
 };
 
 template <class A> struct contentsof_type<volatile A> {
-  typedef typename contentsof_type<A>::type type1;
-  typedef typename boost::remove_reference<type1>::type no_reference;
-  typedef typename detail::IF<
-    is_reference<type1>::value, 
-    volatile no_reference &,
-    volatile no_reference
-  >::RET type;
+  typedef typename contentsof_type<A>::type type;
 };
 
 template <class A> struct contentsof_type<const volatile A> {
-  typedef typename contentsof_type<A>::type type1;
-  typedef typename boost::remove_reference<type1>::type no_reference;
-  typedef typename detail::IF<
-    is_reference<type1>::value, 
-    const volatile no_reference &,
-    const volatile no_reference
-  >::RET type;
+  typedef typename contentsof_type<A>::type type;
 };
 
   // standard iterator traits should take care of the pointer types 
@@ -856,44 +831,6 @@ struct return_type_2<other_action<subscript_action>, A, B> {
 
 };
 
-
-} // namespace lambda
-} // namespace boost
-
-
-// Forward declarations are incompatible with the libstdc++ debug mode.
-#if BOOST_WORKAROUND(__GNUC__, >= 3) && defined(_GLIBCXX_DEBUG)
-#include <string>
-#include <vector>
-#include <map>
-#include <deque>
-#else
-
-// The GCC 2.95.x uses a non-conformant deque
-#if BOOST_WORKAROUND(__GNUC__, == 2) && __GNUC_MINOR__ <= 96
-#include <deque>
-#else
-
-namespace std {
-  template <class T, class Allocator> class deque;
-}
-
-#endif
-
-namespace std {
- template <class Char, class Traits, class Allocator> class basic_string;
- template <class T, class Allocator> class vector;
- template <class Key, class T, class Cmp, class Allocator> class map;
- template <class Key, class T, class Cmp, class Allocator> class multimap;
-}
-
-#endif
-
-
-
-namespace boost { 
-namespace lambda {
-
 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;

module.cmake

@@ -1 +0,0 @@
-boost_module(lambda DEPENDS tuple)

test/CMakeLists.txt

@@ -1,18 +0,0 @@
-boost_additional_test_dependencies(lambda BOOST_DEPENDS test any)
-
-boost_test_run(algorithm_test DEPENDS boost_test_exec_monitor)
-boost_test_run(bind_tests_simple DEPENDS boost_test_exec_monitor)
-boost_test_run(bind_tests_advanced DEPENDS boost_test_exec_monitor)
-boost_test_run(bind_tests_simple_f_refs DEPENDS boost_test_exec_monitor)
-boost_test_run(bll_and_function DEPENDS boost_test_exec_monitor)
-boost_test_run(lambda_cast_test 
-  cast_test.cpp DEPENDS boost_test_exec_monitor)
-boost_test_run(constructor_tests DEPENDS boost_test_exec_monitor)
-boost_test_run(control_structures DEPENDS boost_test_exec_monitor)
-boost_test_run(exception_test DEPENDS boost_test_exec_monitor)
-boost_test_run(extending_rt_traits DEPENDS boost_test_exec_monitor)
-boost_test_run(is_instance_of_test DEPENDS boost_test_exec_monitor)
-boost_test_run(member_pointer_test DEPENDS boost_test_exec_monitor)
-boost_test_run(operator_tests_simple DEPENDS boost_test_exec_monitor)
-boost_test_run(phoenix_control_structures DEPENDS boost_test_exec_monitor)
-boost_test_run(switch_construct DEPENDS boost_test_exec_monitor)

test/Jamfile

@@ -30,4 +30,5 @@ test-suite lambda
     [ run operator_tests_simple.cpp ]
     [ run phoenix_control_structures.cpp ]
     [ run switch_construct.cpp ]
+    [ run ret_test.cpp ]
   ;      

test/operator_tests_simple.cpp

@@ -19,6 +19,8 @@
 
 #include "boost/lambda/detail/suppress_unused.hpp"
 
+#include <boost/shared_ptr.hpp>
+
 #include <vector>
 #include <map>
 #include <set>
@@ -323,8 +325,18 @@ void address_of_and_dereference() {
   
   (*_1 = 7)(it);
   BOOST_CHECK(vi[0] == 7); 
+  const std::vector<int>::iterator cit(it);
+  (*_1 = 8)(cit);
+  BOOST_CHECK(vi[0] == 8);
 
   // TODO: Add tests for more complex iterator types
+
+  boost::shared_ptr<int> ptr(new int(0));
+  (*_1 = 7)(ptr);
+  BOOST_CHECK(*ptr == 7);
+  const boost::shared_ptr<int> cptr(ptr);
+  (*_1 = 8)(cptr);
+  BOOST_CHECK(*ptr == 8);
 }
 
 

test/ret_test.cpp

@@ -0,0 +1,53 @@
+//  ret_test.cpp  - The Boost Lambda Library -----------------------
+//
+// Copyright (C) 2009 Steven Watanabe
+//
+// 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
+
+#include <boost/test/minimal.hpp>
+
+#include <boost/lambda/lambda.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+template<class R, class F>
+void test_ret(R r, F f) {
+    typename F::result_type x = f();
+    BOOST_MPL_ASSERT((boost::is_same<R, typename F::result_type>));
+    BOOST_CHECK(x == r);
+}
+
+template<class R, class F, class T1>
+void test_ret(R r, F f, T1& t1) {
+    typename F::result_type x = f(t1);
+    BOOST_MPL_ASSERT((boost::is_same<R, typename F::result_type>));
+    BOOST_CHECK(x == r);
+}
+
+class add_result {
+public:
+    add_result(int i = 0) : value(i) {}
+    friend bool operator==(const add_result& lhs, const add_result& rhs) {
+        return(lhs.value == rhs.value);
+    }
+private:
+    int value;
+};
+
+class addable {};
+add_result operator+(addable, addable) {
+    return add_result(7);
+}
+
+int test_main(int, char*[]) {
+    addable test;
+    test_ret(add_result(7), boost::lambda::ret<add_result>(boost::lambda::_1 + test), test);
+    test_ret(8.0, boost::lambda::ret<double>(boost::lambda::constant(7) + 1));
+
+    return 0;
+}