Create branches/filesystem-v3 for v2 removal

[SVN r77385]
Remove extraneous semicolon
2025-06-25 20:11:37 +02:00 · 2012-03-18 20:54:17 +00:00 · 2011-10-11 15:23:29 +00:00 · 2011-05-31 21:12:35 +00:00 · 2011-03-21 09:01:18 +00:00 · 2011-01-02 05:13:03 +00:00
7 changed files with 102 additions and 102 deletions
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -7,9 +7,10 @@ project boost/doc ;
 import boostbook : boostbook ;

 boostbook function-doc 
-	: 
-	function.xml 
-	:
+    : 
+    function.xml 
+    :
+        <xsl:param>boost.root=../../../..
        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-	;
+    ;

--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -23,8 +23,8 @@
 // in anything that may be included by function_template.hpp doesn't break
 #include <boost/function/detail/prologue.hpp>

-// Visual Age C++ doesn't handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
+// Older Visual Age C++ version do not handle the file iteration well
+#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
 #  if BOOST_FUNCTION_MAX_ARGS >= 0
 #    include <boost/function/function0.hpp>
 #  endif
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -15,8 +15,8 @@
 #include <string>
 #include <memory>
 #include <new>
-#include <typeinfo>
 #include <boost/config.hpp>
+#include <boost/detail/sp_typeinfo.hpp>
 #include <boost/assert.hpp>
 #include <boost/integer.hpp>
 #include <boost/type_traits/has_trivial_copy.hpp>
@ -54,7 +54,9 @@

 // Borrowed from Boost.Python library: determines the cases where we
 // need to use std::type_info::name to compare instead of operator==.
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
+#if defined( BOOST_NO_TYPEID )
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#elif (defined(__GNUC__) && __GNUC__ >= 3) \
 || defined(_AIX) \
 || (   defined(__sgi) && defined(__host_mips))
 #  include <cstring>
@ -103,7 +105,7 @@ namespace boost {
        // For pointers to std::type_info objects
        struct type_t {
          // (get_functor_type_tag, check_functor_type_tag).
-          const BOOST_FUNCTION_STD_NS::type_info* type;
+          const detail::sp_typeinfo* type;

          // Whether the type is const-qualified.
          bool const_qualified;
@ -201,11 +203,11 @@ namespace boost {
        {
          switch (op) {
          case clone_functor_tag: 
-            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            out_buffer.obj_ref = in_buffer.obj_ref;
            return;

          case move_functor_tag:
-            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            out_buffer.obj_ref = in_buffer.obj_ref;
            in_buffer.obj_ref.obj_ptr = 0;
            return;

@ -215,12 +217,12 @@ namespace boost {

          case check_functor_type_tag:
            {
-              const BOOST_FUNCTION_STD_NS::type_info& check_type 
+              const detail::sp_typeinfo& check_type 
                = *out_buffer.type.type;

              // Check whether we have the same type. We can add
              // cv-qualifiers, but we can't take them away.
-              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
                  && (!in_buffer.obj_ref.is_const_qualified 
                      || out_buffer.type.const_qualified)
                  && (!in_buffer.obj_ref.is_volatile_qualified
@ -232,7 +234,7 @@ namespace boost {
            return;

          case get_functor_type_tag:
-            out_buffer.type.type = &typeid(F);
+            out_buffer.type.type = &BOOST_SP_TYPEID(F);
            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
            return;
@ -262,12 +264,12 @@ namespace boost {
          A(a)
        {
        }
-	
-	functor_wrapper(const functor_wrapper& f) :
+        
+        functor_wrapper(const functor_wrapper& f) :
          F(static_cast<const F&>(f)),
          A(static_cast<const A&>(f))
-	{
-	}
+        {
+        }
      };

      /**
@ -292,14 +294,14 @@ namespace boost {
          } else if (op == destroy_functor_tag)
            out_buffer.func_ptr = 0;
          else if (op == check_functor_type_tag) {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+            const detail::sp_typeinfo& check_type 
              = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = &in_buffer.func_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
@ -313,23 +315,27 @@ namespace boost {
          if (op == clone_functor_tag || op == move_functor_tag) {
            const functor_type* in_functor = 
              reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new ((void*)&out_buffer.data) functor_type(*in_functor);
+            new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);

            if (op == move_functor_tag) {
-              reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
+              functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
+              (void)f; // suppress warning about the value of f not being used (MSVC)
+              f->~Functor();
            }
          } else if (op == destroy_functor_tag) {
            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
-            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+             functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
+             (void)f; // suppress warning about the value of f not being used (MSVC)
+             f->~Functor();
          } else if (op == check_functor_type_tag) {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+            const detail::sp_typeinfo& check_type 
              = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = &in_buffer.data;
            else
              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;            
          }
@ -367,8 +373,10 @@ namespace boost {
            // Clone the functor
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
+            // jewillco: Changing this to static_cast because GCC 2.95.3 is
+            // obsolete.
            const functor_type* f =
-              (const functor_type*)(in_buffer.obj_ptr);
+              static_cast<const functor_type*>(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
@ -381,14 +389,14 @@ namespace boost {
            delete f;
            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type
+            const detail::sp_typeinfo& check_type
              = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
@ -423,7 +431,7 @@ namespace boost {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
-            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
            return;
@ -472,7 +480,7 @@ namespace boost {
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
            const functor_wrapper_type* f =
-              (const functor_wrapper_type*)(in_buffer.obj_ptr);
+              static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
            wrapper_allocator.construct(copy, *f);
@ -492,14 +500,14 @@ namespace boost {
            wrapper_allocator.deallocate(victim,1);
            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+            const detail::sp_typeinfo& check_type 
              = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
          }
@ -526,7 +534,7 @@ namespace boost {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
-            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
            return;
@ -627,11 +635,11 @@ public:
  /** Determine if the function is empty (i.e., has no target). */
  bool empty() const { return !vtable; }

-  /** Retrieve the type of the stored function object, or typeid(void)
+  /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
      if this is empty. */
-  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
+  const detail::sp_typeinfo& target_type() const
  {
-    if (!vtable) return typeid(void);
+    if (!vtable) return BOOST_SP_TYPEID(void);

    detail::function::function_buffer type;
    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
@ -644,7 +652,7 @@ public:
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.type.type = &typeid(Functor);
+      type_result.type.type = &BOOST_SP_TYPEID(Functor);
      type_result.type.const_qualified = is_const<Functor>::value;
      type_result.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result, 
@ -662,14 +670,14 @@ public:
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.type.type = &typeid(Functor);
+      type_result.type.type = &BOOST_SP_TYPEID(Functor);
      type_result.type.const_qualified = true;
      type_result.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result, 
                      detail::function::check_functor_type_tag);
      // GCC 2.95.3 gets the CV qualifiers wrong here, so we
      // can't do the static_cast that we should do.
-      return (const Functor*)(type_result.obj_ptr);
+      return static_cast<const Functor*>(type_result.obj_ptr);
    }

  template<typename F>
@ -713,7 +721,7 @@ public:
 public: // should be protected, but GCC 2.95.3 will fail to allow access
  detail::function::vtable_base* get_vtable() const {
    return reinterpret_cast<detail::function::vtable_base*>(
-             reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
  }

  bool has_trivial_copy_and_destroy() const {
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
@ -486,19 +486,19 @@ namespace boost {
                                            BOOST_FUNCTION_TEMPLATE_ARGS);

        template<typename F>
-        bool assign_to(F f, function_buffer& functor)
+        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
-        bool assign_to_a(F f, function_buffer& functor, Allocator a)
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

-        void clear(function_buffer& functor)
+        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
@ -508,13 +508,13 @@ namespace boost {
        // Function pointers
        template<typename FunctionPtr>
        bool 
-        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {
            // should be a reinterpret cast, but some compilers insist
            // on giving cv-qualifiers to free functions
-            functor.func_ptr = (void (*)())(f);
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
@ -522,7 +522,7 @@ namespace boost {
        }
        template<typename FunctionPtr,typename Allocator>
        bool 
-        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }
@ -530,26 +530,26 @@ namespace boost {
        // Member pointers
 #if BOOST_FUNCTION_NUM_ARGS > 0
        template<typename MemberPtr>
-        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {
          // DPG TBD: Add explicit support for member function
          // objects, so we invoke through mem_fn() but we retain the
          // right target_type() values.
          if (f) {
-            this->assign_to(mem_fn(f), functor);
+            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
-        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {
          // DPG TBD: Add explicit support for member function
          // objects, so we invoke through mem_fn() but we retain the
          // right target_type() values.
          if (f) {
-            this->assign_to_a(mem_fn(f), functor, a);
+            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
@ -561,13 +561,13 @@ namespace boost {
        // Assign to a function object using the small object optimization
        template<typename FunctionObj>
        void 
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
-          new ((void*)&functor.data) FunctionObj(f);
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }
@ -575,13 +575,13 @@ namespace boost {
        // Assign to a function object allocated on the heap.
        template<typename FunctionObj>
        void 
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
@ -596,7 +596,7 @@ namespace boost {

        template<typename FunctionObj>
        bool 
-        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor, 
@ -608,7 +608,7 @@ namespace boost {
        }
        template<typename FunctionObj,typename Allocator>
        bool 
-        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
@ -623,9 +623,9 @@ namespace boost {
        template<typename FunctionObj>
        bool 
        assign_to(const reference_wrapper<FunctionObj>& f, 
-                  function_buffer& functor, function_obj_ref_tag)
+                  function_buffer& functor, function_obj_ref_tag) const
        {
-          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
@ -633,7 +633,7 @@ namespace boost {
        template<typename FunctionObj,typename Allocator>
        bool 
        assign_to_a(const reference_wrapper<FunctionObj>& f, 
-                  function_buffer& functor, Allocator, function_obj_ref_tag)
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }
@ -677,7 +677,7 @@ namespace boost {

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
-               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
    }

    struct clear_type {};
@ -751,9 +751,6 @@ namespace boost {

    ~BOOST_FUNCTION_FUNCTION() { clear(); }

-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    // MSVC 6.0 and prior require all definitions to be inline, but
-    // these definitions can become very costly.
    result_type operator()(BOOST_FUNCTION_PARMS) const
    {
      if (this->empty())
@ -762,9 +759,6 @@ namespace boost {
      return get_vtable()->invoker
               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
    }
-#else
-    result_type operator()(BOOST_FUNCTION_PARMS) const;
-#endif

    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
    // when to use self_type is obnoxious. MSVC cannot handle self_type as
@ -864,7 +858,7 @@ namespace boost {
 #else
  private:
    struct dummy {
-      void nonnull() {};
+      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();
@ -909,7 +903,7 @@ namespace boost {
      // static initialization. Otherwise, we will have a race
      // condition here in multi-threaded code. See
      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
-      static vtable_type stored_vtable = 
+      static const vtable_type stored_vtable = 
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
@ -917,7 +911,7 @@ namespace boost {
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= (std::size_t)0x01;
+          value |= static_cast<size_t>(0x01);
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else 
        vtable = 0;
@ -943,7 +937,7 @@ namespace boost {
      // static initialization. Otherwise, we will have a race
      // condition here in multi-threaded code. See
      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
-      static vtable_type stored_vtable =
+      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) { 
@ -951,7 +945,7 @@ namespace boost {
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= (std::size_t)0x01;
+          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
      } else 
        vtable = 0;
@ -998,22 +992,6 @@ namespace boost {
    f1.swap(f2);
  }

-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  typename BOOST_FUNCTION_FUNCTION<
-      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type
-  inline 
-  BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
-  ::operator()(BOOST_FUNCTION_PARMS) const
-  {
-    if (this->empty())
-      boost::throw_exception(bad_function_call());
-
-    return get_vtable()->invoker
-             (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
-  }
-#endif
-
 // Poison comparisons between boost::function objects of the same type.
 template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  void operator==(const BOOST_FUNCTION_FUNCTION<
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -8,6 +8,7 @@
 # For more information, see http://www.boost.org/

 project
+    : requirements <toolset>msvc:<asynch-exceptions>on
    : source-location $(BOOST_ROOT)
    ;

--- a/test/mem_fun_cxx98.cpp
+++ b/test/mem_fun_cxx98.cpp
@ -10,22 +10,28 @@

    
 #include <boost/function.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

 struct X {
  int foo(int);
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }

 int main()
 {
    boost::function<int (X*, int)> f;
+    boost::function<std::ostream& (X*, std::ostream&)> f2;

-f = &X::foo;
-  
-X x;
-f(&x, 5);
+    f = &X::foo;
+    f2 = &X::foo2;

-    return 0;
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
+
+    return ::boost::report_errors();
 }
--- a/test/mem_fun_portable.cpp
+++ b/test/mem_fun_portable.cpp
@ -10,22 +10,28 @@

    
 #include <boost/function.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

 struct X {
  int foo(int);
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }

 int main()
 {
    boost::function2<int, X*, int> f;
+    boost::function2<std::ostream&, X*, std::ostream&> f2;

-f = &X::foo;
-  
-X x;
-f(&x, 5);
+    f = &X::foo;
+    f2 = &X::foo2;

-    return 0;
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
+
+    return ::boost::report_errors();
 }
Author	SHA1	Message	Date
Beman Dawes	8041d8590e	Create branches/filesystem-v3 for v2 removal [SVN r77385]	2012-03-18 20:54:17 +00:00
Marshall Clow	775213a9e6	Remove extraneous semicolon [SVN r74916]	2011-10-11 15:23:29 +00:00
Marshall Clow	cbb9e7c4da	Applied patch from #4717 [SVN r72316]	2011-05-31 21:12:35 +00:00
Daniel James	7ee94c6975	Function: Extra member tests, to catch #4073 . [SVN r70301]	2011-03-21 09:01:18 +00:00
Steven Watanabe	8cde82a568	Remove extra definition of operator(), since it's inline anyway. Fixes #4765 . [SVN r67560]	2011-01-02 05:13:03 +00:00
Daniel James	9ea95b071b	Detab some jamfiles. [SVN r63343]	2010-06-26 12:10:47 +00:00
Daniel James	09fc8792fa	Update various libraries' documentation build. Mostly to use the images and css files under doc/src instead of doc/html, usually be deleting the settings in order to use the defaults. Also add 'boost.root' to some builds in order to fix links which rely on it. [SVN r63146]	2010-06-20 18:00:48 +00:00
Steven Watanabe	c0d4005441	Make sure that the cv flags are copied when we copy a reference to a function object. Fixes #4325 [SVN r62665]	2010-06-09 15:40:48 +00:00
Jeremiah Willcock	6902f6f943	Applied patch from #4073 ; fixes #4073 [SVN r62623]	2010-06-09 00:51:41 +00:00
Jeremiah Willcock	c4f1ce7cb1	Applied patch from #3912 ; fixes #3912 [SVN r62622]	2010-06-09 00:49:45 +00:00
Jeremiah Willcock	820ad024fe	Applied patch from #3618 ; fixes #3618 [SVN r62621]	2010-06-09 00:47:51 +00:00
Jeremiah Willcock	2e19728cdb	Removed all but one old-style cast, breaking GCC 2.95.3; fixes #3410 [SVN r62614]	2010-06-08 23:55:25 +00:00
Jeremiah Willcock	de3b8e7451	Fixed tab and no-newline-at-end-of-file issues from inspection report [SVN r61435]	2010-04-20 17:54:16 +00:00
Peter Dimov	22c6592a40	Fix function_base.hpp to not require typeid. Refs #3666 . Requires [58127]. [SVN r58128]	2009-12-03 20:59:32 +00:00
Troy D. Straszheim	a1f62de420	rm cmake from trunk. I'm not entirely sure this is necessary to satisfy the inspect script, but I'm not taking any chances, and it is easy to put back [SVN r56942]	2009-10-17 02:07:38 +00:00
Troy D. Straszheim	81c7876588	Copyrights on CMakeLists.txt to keep them from clogging up the inspect reports. This is essentially the same commit as r55095 on the release branch. [SVN r55159]	2009-07-26 00:49:56 +00:00
Daniel James	2020d39e2c	Fix a typo. [SVN r54909]	2009-07-12 15:53:54 +00:00
Daniel James	8b63c146ea	Work around Visual C++ copy constructor bug. Fixes #2929 . Based on the patch by Steven Watanabe. [SVN r54619]	2009-07-03 22:22:03 +00:00
Daniel James	ae534d7342	Fix Boost.Function unit tests for C++0x. Fixes #3012 Based on a patch from Richard Webb. Changed a bit so that it also works for the Visual C++ 10 beta. [SVN r54618]	2009-07-03 22:21:40 +00:00
Daniel James	e8247198fa	Add 'and later versions' to support info for GCC and Visual C++. Fixes #2847 . I didn't explicitly specify the versions since no one's updating this list and it's highly unlikely that a future version will break this. The same could probably be done for the other compilers but I don't know them very well so I'm leaving them alone. [SVN r54617]	2009-07-03 22:20:52 +00:00
Daniel James	ff3244d562	When copying boost::ref, copy even when the referenced function is empty. Fixes #2642 Patch by Steven Watanabe [SVN r54616]	2009-07-03 22:20:26 +00:00
Vladimir Prus	68128bfffa	Make Boost.Function compile with disabled exceptions. Closes #2900. Patch from Gabi Davar. [SVN r53722]	2009-06-07 15:44:50 +00:00
Daniel James	e10f4eaef9	Add missing #pragma warning(pop). Fixes #2767 . [SVN r53694]	2009-06-06 15:31:47 +00:00
Douglas Gregor	a74e72cce9	Make Boost.Function compile under BOOST_NO_EXCEPTIONS. Fixes #2499 Fixes #2494 Fixes #2469 Fixes #2466 [SVN r51745]	2009-03-13 05:49:02 +00:00
Douglas Gregor	6f8ec5c8c5	Implement an optimization that David Abrahams and myself came up with, where Boost.Function uses a bit in the vtable pointer to indicate when the target function object has a trivial copy constructor, trivial destructor, and fits within the small object buffer. In this case, we just copy the bits of the function object rather than performing an indirect call to the manager. This results in a 60% speedup on a micro-benchmark that copies and calls such function objects repeatedly. [SVN r51743]	2009-03-13 05:23:53 +00:00
John Maddock	678fb133f0	Add PDF generation options to fix external links to point to the web site. Added a few more Boostbook based libs that were missed first time around. Fixed PDF naming issues. [SVN r51284]	2009-02-17 10:05:58 +00:00
John Maddock	821e6d34dd	Fix -Wundef warning and suspect usage of BOOST_STRICT_CONFIG. [SVN r50064]	2008-12-02 10:10:46 +00:00
Michael A. Jackson	529dc74954	Updating dependency information for modularized libraries. [SVN r49628]	2008-11-07 17:05:27 +00:00
Michael A. Jackson	e8504c1777	Updating CMake files to latest trunk. Added dependency information for regression tests and a few new macros for internal use. [SVN r49627]	2008-11-07 17:02:56 +00:00
K. Noel Belcourt	07800455a8	Both Sun and Pgi on Linux correctly put typeinfo into the std namespace, but function_base keys off the BOOST_NO_EXCEPTION_STD_NAMESPACE macro instead of the BOOST_NO_STD_TYPEINFO macro. The attached patch changes function_base to use the typeinfo macro. Because eVC 4.2 doesn't put typeinfo into the std namespace, I need to define BOOST_NO_STD_TYPEINFO only for this eVC version. [SVN r49571]	2008-11-03 18:37:49 +00:00
Michael A. Jackson	f559986ae8	Continuing merge of CMake build system files into trunk with the encouragement of Doug Gregor [SVN r49510]	2008-11-01 13:15:41 +00:00
Douglas Gregor	8ca7384121	Fix Boost.Function thread safety issue again [SVN r49326]	2008-10-14 15:31:57 +00:00
Douglas Gregor	75890fea53	CodeGear C++ fix, from Nicola Musatti. Fixes #2325 [SVN r48922]	2008-09-23 00:26:21 +00:00
Douglas Gregor	da259e8dce	Make MyLargeFunctor large. [SVN r48633]	2008-09-06 16:30:58 +00:00
Douglas Gregor	2fe4cc253f	Fix double-destruction problem with small function objects and swap(), and try to work around a GCC 4.2 issue. See #1910 for comments about the former problem from Niels Dekker. [SVN r48627]	2008-09-06 03:16:25 +00:00
Douglas Gregor	f379ef8532	Make Boost.Function's target() operation respect the cv-qualifiers of referenced function objects. Fixes #736 [SVN r48618]	2008-09-05 17:52:12 +00:00
Douglas Gregor	ea18f5777b	Add Boost.Typeof support to Boost.Function. Fixes #1621 [SVN r48616]	2008-09-05 16:13:49 +00:00
Douglas Gregor	d5a86a2d52	Improve the performance of Boost.Function's swap. Thanks to Niels Dekker for the original patch. Fixes #1910 [SVN r48615]	2008-09-05 15:43:22 +00:00
Douglas Gregor	e3dfa7268a	Add forward-declaration header for Boost.Function. Fixes #1668 [SVN r48613]	2008-09-05 14:55:34 +00:00
Douglas Gregor	bacb5d6752	Attempt to work around problem with allocator casts in Boost.Function [SVN r46446]	2008-06-17 13:59:04 +00:00
Douglas Gregor	04040ae566	Improve documentation on the size/efficiency of boost::function objects [SVN r44852]	2008-04-28 14:11:46 +00:00
John Maddock	fe2d04e954	Change <functional> include so that it still works when Boost.TR1 is in the include path. [SVN r44506]	2008-04-17 15:49:39 +00:00
Douglas Gregor	0936dbdd03	Add missing include for is_void [SVN r44030]	2008-04-04 12:26:53 +00:00
Douglas Gregor	adb7b0a214	Change Boost.Function allocator behavior, from Emil Dotchevski [SVN r43884]	2008-03-27 19:44:37 +00:00
Douglas Gregor	cead36cd5b	Disable more Visual C++ warnings in Function headers. Fixes #1416 [SVN r41798]	2007-12-06 18:39:06 +00:00
Douglas Gregor	81e558491b	Merge lots of copyrights [SVN r40811]	2007-11-05 21:22:29 +00:00
John Maddock	2378ba59e7	Fix for Borland compilers. [SVN r39657]	2007-10-02 17:41:35 +00:00
Douglas Gregor	53b95c386d	Finalizes the fix to Bug #1260 , making vtable_base an actual POD type (oops) and playing more nicely with reinterpret_cast (thanks to Brad King for the fixes). [SVN r39285]	2007-09-14 21:05:46 +00:00
Douglas Gregor	3312c7ffcd	function_template.hpp: - Pass-by-reference internally, when we can. Fixes #1067 [SVN r39244]	2007-09-13 19:06:53 +00:00
Douglas Gregor	de27ae9697	function/function_base.hpp, function/function_template.hpp: - Switch from dynamic initialization of the vtable pointer to static initialization (Fixes #1260) - Handle member pointers properly, only using mem_fn within the invoker to deal with all of the messy bits of calling member pointers [SVN r39240]	2007-09-13 17:38:58 +00:00
Douglas Gregor	a7b9940f15	Handle GCC's -fno-exceptions properly. Fixes #1198 [SVN r39061]	2007-08-29 19:06:11 +00:00
Douglas Gregor	e4f165a4e8	Disable MSVC warning about native code generation. Fixes #1163 [SVN r39060]	2007-08-29 18:59:16 +00:00
Douglas Gregor	80a3f47099	Committed patch to eliminate warnings with GCC's -Wundef. Fixes #1197 [SVN r38827]	2007-08-21 15:35:19 +00:00
Vladimir Prus	2a85edbd31	Remove V1 Jamfiles [SVN r38516]	2007-08-08 19:02:26 +00:00
Douglas Gregor	5c514ebe35	Try to work around EC++4 bug [SVN r37471]	2007-04-18 12:13:53 +00:00
Beman Dawes	6a3f0df553	Add copyright, license [SVN r35905]	2006-11-07 19:11:57 +00:00
Douglas Gregor	64c8d10fa8	Eliminate MSVC 8.0 warning [SVN r35588]	2006-10-13 14:29:56 +00:00
Peter Dimov	a2a810d2c1	Put back #include <functional> in case functionN.hpp is used directly [SVN r34519]	2006-07-12 22:12:01 +00:00
Peter Dimov	d84481361f	TR1 cyclic dependency fixes. [SVN r34499]	2006-07-10 13:17:41 +00:00
Peter Dimov	872f12efee	TR1 conformance: derive from unary_function/binary_function [SVN r34481]	2006-07-08 18:07:33 +00:00