Release 1.29.0 beta 1

[SVN r52601]

CMakeLists.txt

@@ -0,0 +1,21 @@
+#----------------------------------------------------------------------------
+# 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 
+)
+
+

doc/Jamfile.v2

@@ -1,5 +1,11 @@
 project boost/doc ;
 import boostbook : boostbook ;
 
-boostbook lambda-doc : lambda.xml ;
+# Are these really the correct images??
+path-constant images : ../../spirit/phoenix/doc/html ;
+
+boostbook lambda-doc : lambda.xml 
+:
+   <format>pdf:<xsl:param>img.src.path=$(images)/
+;
 

doc/lambda.xml

@@ -44,7 +44,7 @@
     <para>
 
       The Boost Lambda Library (BLL in the sequel) is a C++ template
-      library, which implements a form of <emphasis>lambda abstractions</emphasis> for C++.
+      library, which implements form of <emphasis>lambda abstractions</emphasis> for C++.
 The term originates from functional programming and lambda calculus, where a lambda abstraction defines an unnamed function.
       The primary motivation for the BLL is to provide flexible and
       convenient means to define unnamed function objects for STL algorithms.
@@ -1908,7 +1908,7 @@ For example:
 int foo(int); int bar(int);
 ...
 int i;
-bind(foo, bind(bar, _1)(i);
+bind(foo, bind(bar, _1))(i);
 </programlisting>
 
 The last line makes the call <literal>foo(bar(i));</literal>
@@ -3191,7 +3191,7 @@ to extend the library with new features.
 
 
 
-<section>
+<appendix>
 <title>Rationale for some of the design decisions</title>
 
 <section id="lambda.why_weak_arity">
@@ -3256,7 +3256,7 @@ was dropped.
 
 </section>
 
-</section>
+</appendix>
 
 
 

include/boost/lambda/casts.hpp

@@ -14,6 +14,8 @@
 #if !defined(BOOST_LAMBDA_CASTS_HPP)
 #define BOOST_LAMBDA_CASTS_HPP
 
+#include "boost/lambda/detail/suppress_unused.hpp"
+
 #include <typeinfo>
 
 namespace boost { 
@@ -64,11 +66,12 @@ public:
   }
 };
 
-  // typedid action
+// typeid action
 class typeid_action {
 public:
   template<class RET, class Arg1>
   static RET apply(Arg1 &a1) {
+    detail::suppress_unused_variable_warnings(a1);
     return typeid(a1);
   }
 };

include/boost/lambda/detail/lambda_functor_base.hpp

@@ -16,6 +16,10 @@
 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
@@ -42,6 +46,10 @@ public:
   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); }
 
@@ -337,7 +345,7 @@ class lambda_functor_base<action<0, Act>, Args>
 {  
 public:  
 //  Args args; not needed
-  explicit lambda_functor_base(const Args& a) {}  
+  explicit lambda_functor_base(const Args& /*a*/) {}  
   
   template<class SigArgs> struct sig {  
     typedef typename return_type_N<Act, null_type>::type type;

include/boost/lambda/detail/lambda_functors.hpp

@@ -105,7 +105,10 @@ typedef const lambda_functor<placeholder<THIRD> >  placeholder3_type;
 // 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>
@@ -244,6 +247,9 @@ public:
   } 
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#pragma warning(pop)
+#endif
 
 } // namespace lambda
 } // namespace boost

include/boost/lambda/detail/lambda_traits.hpp

@@ -430,6 +430,56 @@ 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;

include/boost/lambda/detail/operator_return_type_traits.hpp

@@ -233,28 +233,31 @@ template <class A> struct contentsof_type<const A> {
   // 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 detail::IF<
+  typedef typename boost::remove_reference<type1>::type no_reference;
+  typedef typename detail::IF<
       is_reference<type1>::value, 
-      const typename boost::remove_reference<type1>::type &,
-      const type1
+      const no_reference &,
+      const no_reference
   >::RET 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 typename boost::remove_reference<type1>::type &,
-    volatile type1
+    volatile no_reference &,
+    volatile no_reference
   >::RET 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 typename boost::remove_reference<type1>::type &,
-    const volatile type1
+    const volatile no_reference &,
+    const volatile no_reference
   >::RET type;
 };
 
@@ -933,6 +936,41 @@ struct plain_return_type_2<other_action<subscript_action>, const std::basic_stri
   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

include/boost/lambda/detail/operators.hpp

@@ -258,17 +258,17 @@ operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
 #error "Multiple defines of  BOOST_LAMBDA_PTR_ARITHMETIC_E1"
 #endif
 
-#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB)            \
+#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]> >   \
+  lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >    \
 >                                                                           \
-OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                    \
+OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                     \
 {                                                                           \
-  return lambda_functor<                                                    \
-    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
-  >(tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                       \
+  return                                                                    \
+    lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> >  \
+  (tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b));                         \
 }
 
 
@@ -276,15 +276,15 @@ OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N])                    \
 #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<                                                              \
+#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                                                                     \
+{                                                                           \
+  return                                                                    \
     lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
     (tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b));                      \
 }

include/boost/lambda/detail/suppress_unused.hpp

@@ -0,0 +1,27 @@
+// Boost Lambda Library  suppress_unused.hpp -----------------------------
+//
+// 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
+
+// ------------------------------------------------------------
+
+#ifndef BOOST_LAMBDA_SUPRESS_UNUSED_HPP
+#define BOOST_LAMBDA_SUPRESS_UNUSED_HPP
+
+namespace boost { 
+namespace lambda {
+namespace detail {
+
+template<class T>
+inline void suppress_unused_variable_warnings(const T&) {}
+
+}
+}
+}
+
+#endif

include/boost/lambda/switch.hpp

@@ -465,12 +465,18 @@ BOOST_LAMBDA_SWITCH( BOOST_PP_INC(N) )
 #define BOOST_LAMBDA_SWITCH_STATEMENT_HELPER(z, N, A) \
 BOOST_LAMBDA_SWITCH_STATEMENT(BOOST_PP_INC(N))
 
-
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4065)
+#endif
 
   // up to 9 cases supported (counting default:)
 BOOST_PP_REPEAT_2ND(9,BOOST_LAMBDA_SWITCH_HELPER,FOO)
 BOOST_PP_REPEAT_2ND(9,BOOST_LAMBDA_SWITCH_STATEMENT_HELPER,FOO)
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
 
 } // namespace lambda 
 } // namespace boost

module.cmake

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

test/CMakeLists.txt

@@ -0,0 +1,18 @@
+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

@@ -11,7 +11,7 @@
 import testing ;
 
 project 
-  : requirements <library>/boost/test//boost_test_exec_monitor
+  : requirements <toolset>msvc:<asynch-exceptions>on
   ;
           
 test-suite lambda

test/constructor_tests.cpp

@@ -24,6 +24,10 @@
 #include <algorithm>
 #include <vector>
 
+#ifdef BOOST_MSVC
+#pragma warning(disable:4512)
+#endif
+
 using namespace boost::lambda;
 using namespace std;
 
@@ -34,7 +38,7 @@ bool check_tuple(int n, const T& t)
 }
 
 template <>
-bool check_tuple(int n, const null_type& ) { return true; }
+bool check_tuple(int /*n*/, const null_type& ) { return true; }
 
 
 void constructor_all_lengths() 
@@ -183,7 +187,7 @@ public:
 void test_destructor ()
 { 
   char space[sizeof(is_destructor_called)];
-  bool flag;
+  bool flag = false;
 
   is_destructor_called* idc = new(space) is_destructor_called(flag);
   BOOST_CHECK(flag == false);

test/exception_test.cpp

@@ -29,7 +29,7 @@ using namespace boost::lambda;
 using namespace std;
 
 // to prevent unused variables warnings
-template <class T> void dummy(const T& t) {}
+template <class T> void dummy(const T&) {}
 
 void erroneous_exception_related_lambda_expressions() {
 
@@ -603,7 +603,7 @@ int test_main(int, char *[]) {
     return_type_matching();
     test_empty_catch_blocks();
   }
-  catch (int x)
+  catch (int)
   {
     BOOST_CHECK(false);
   }

test/extending_rt_traits.cpp

@@ -16,6 +16,7 @@
 
 #include "boost/lambda/bind.hpp"
 #include "boost/lambda/lambda.hpp"
+#include "boost/lambda/detail/suppress_unused.hpp"
 
 #include <iostream>
 
@@ -23,6 +24,8 @@
 
 #include <algorithm>
 
+using boost::lambda::detail::suppress_unused_variable_warnings;
+
 class A {};
 class B {};
 
@@ -81,7 +84,7 @@ struct plain_return_type_1<other_action<contentsof_action>, A> {
 } // lambda
 } // boost
 
-void ok(B b) {}
+void ok(B /*b*/) {}
 
 void test_unary_operators() 
 {
@@ -127,7 +130,7 @@ class my_vector {};
 
 template<class A, class B> 
 my_vector<typename return_type_2<arithmetic_action<plus_action>, A&, B&>::type>
-operator+(const my_vector<A>& a, const my_vector<B>& b)
+operator+(const my_vector<A>& /*a*/, const my_vector<B>& /*b*/)
 {
   typedef typename 
     return_type_2<arithmetic_action<plus_action>, A&, B&>::type res_type;
@@ -175,8 +178,8 @@ Z operator^=( X&, const Y&) { return Z(); }
 // assignment
 class Assign {
 public:
-  void operator=(const Assign& a) {}
-  X operator[](const int& i) { return X(); }
+  void operator=(const Assign& /*a*/) {}
+  X operator[](const int& /*i*/) { return X(); }
 };
 
 
@@ -329,9 +332,16 @@ void test_binary_operators() {
   XX dummy3 = (_1 * _2)(vxx, vyy);
   VV dummy4 = (_1 * _2)(cvxx, cvyy);
 
+  suppress_unused_variable_warnings(dummy1);
+  suppress_unused_variable_warnings(dummy2);
+  suppress_unused_variable_warnings(dummy3);
+  suppress_unused_variable_warnings(dummy4);
+
   my_vector<int> v1; my_vector<double> v2;
   my_vector<double> d = (_1 + _2)(v1, v2);
 
+  suppress_unused_variable_warnings(d);
+
   // bitwise
 
   (_1 << _2)(x, y);

test/member_pointer_test.cpp

@@ -118,11 +118,11 @@ class C {};
 class D {};
 
 // ->* can be overloaded to do anything
-bool operator->*(A a, B b) {
+bool operator->*(A /*a*/, B /*b*/) {
   return false; 
 }
 
-bool operator->*(B b, A a) {
+bool operator->*(B /*b*/, A /*a*/) {
   return true; 
 }
 

test/operator_tests_simple.cpp

@@ -17,6 +17,8 @@
 
 #include "boost/lambda/lambda.hpp"
 
+#include "boost/lambda/detail/suppress_unused.hpp"
+
 #include <vector>
 #include <map>
 #include <set>
@@ -96,6 +98,8 @@ void arithmetic_operators() {
   // test that unary plus really does something
   unary_plus_tester u;
   unary_plus_tester up = (+_1)(u);
+
+  boost::lambda::detail::suppress_unused_variable_warnings(up);
 }
 
 void bitwise_operators() {