[Boost-commit] svn:boost r66223 - sandbox/function/boost/function

Subject: [Boost-commit] svn:boost r66223 - sandbox/function/boost/function
From: dsaritz_at_[hidden]
Date: 2010-10-28 05:37:08

Author: psiha
Date: 2010-10-28 05:37:04 EDT (Thu, 28 Oct 2010)
New Revision: 66223
URL: http://svn.boost.org/trac/boost/changeset/66223

Log:
Many compilation error fixes.
Removed the no longer used trivial_heap_storage_atom typedef.
Replaced some SFINAE based dispatch with tag based dispatch.
Fixed assignment of different boost::function<> instantiations as well as empty boost::ref() wrapped function objects.
Minor stylistic changes.
Text files modified: 
   sandbox/function/boost/function/function_base.hpp     |   149 ++++++++++++++++++++------------------- 
   sandbox/function/boost/function/function_template.hpp |     9 +                                       
   2 files changed, 85 insertions(+), 73 deletions(-)

Modified: sandbox/function/boost/function/function_base.hpp
==============================================================================
--- sandbox/function/boost/function/function_base.hpp	(original)
+++ sandbox/function/boost/function/function_base.hpp	2010-10-28 05:37:04 EDT (Thu, 28 Oct 2010)
@@ -158,29 +158,35 @@
             template <class Other>
             struct rebind { typedef fallocator<Other> other; };
 
+            //...zzz...the two constructors make it non-stateless...
             fallocator() {}
 
-            template <class Other>
-            fallocator( fallocator<Other> const & ) {}
+            template <class Other> fallocator( fallocator<Other> const & ) {}
 
-            static pointer       address( reference       value ) { return addressof( value ); }
-            static const_pointer address( const_reference value ) { return addressof( value ); }
+            template <class Other>
+            fallocator & operator=( fallocator<Other> const & ) { return *this; }
 
             template <class Other>
-            fallocator<Other> & operator=( fallocator<Other> const & ) { return *this; }
+            bool operator==( fallocator<Other> const & ) const { return true; }
+
+            static pointer       address( reference       value ) { return boost::addressof( value ); }
+            static const_pointer address( const_reference value ) { return boost::addressof( value ); }
 
             pointer allocate  ( size_type const count, void const * /*p_hint*/ ) { return allocate( count ); }
-            pointer allocate  ( size_type const count                          ) { return ::operator new( count * sizeof( T ) ); }
-            void    deallocate( pointer   const ptr  , size_type const /*count*/ ) { ::operator delete( ptr ); }
+            pointer allocate  ( size_type const count                          ) { return static_cast<pointer>( ::operator new( count * sizeof( T ) ) ); }
+            void    deallocate( pointer   const ptr  , size_type /*count*/     ) { deallocate( ptr ); }
+            void    deallocate( pointer   const ptr                            ) { ::operator delete( ptr ); }
 
             void construct( pointer const ptr, T const & source ) { new ( ptr ) T( source ); }
-            void destroy  ( pointer const ptr                   ) { ptr->~T(); }
+            void destroy  ( pointer const ptr                   ) { ptr->~T(); ignore_unused_variable_warning( ptr ); }
 
             static size_type max_size() { return (std::numeric_limits<size_type>::max)() / sizeof( T ); }
         };
 
         typedef fallocator<void *> dummy_allocator;
 
+        //...zzz...BOOST_STATIC_ASSERT( is_stateless<dummy_allocator>::value );
+
         struct thiscall_optimization_available_helper
         {
             static void free_function () {}
@@ -210,10 +216,10 @@
           template <typename Functor>
           typed_functor( Functor & functor )
               :
-              pFunctor          ( addressof      ( functor )  ),
-              type_id           ( BOOST_SP_TYPEID( Functor )  ),
-              const_qualified   ( is_const   <Functor>::value ),
-              volatile_qualified( is_volatile<Functor>::value )
+              pFunctor          ( boost::addressof( functor )  ),
+              type_id           ( BOOST_SP_TYPEID( Functor )   ),
+              const_qualified   ( is_const   <Functor>::value  ),
+              volatile_qualified( is_volatile<Functor>::value  )
           {
               BOOST_ASSERT( pFunctor );
           }
@@ -288,7 +294,7 @@
         struct trivial_heap_obj_t
         {
             void        * ptr;
-            std::size_t   size; // in number of allocation atoms
+            std::size_t   size; // in number of bytes
         } trivial_heap_obj;
 
         // For function pointers of all kinds
@@ -380,7 +386,7 @@
           >
       {};
 
-      template<typename F>
+      template <typename F>
       class get_function_tag
       {
         typedef typename mpl::if_c<(is_pointer<F>::value || is_msvc_exception_specified_function_pointer<F>::value),
@@ -405,14 +411,13 @@
       {
         functor_and_allocator( F const & f, A a ) : F( f ), A( a ) {}
 
-        F & functor  () { return *this; }
-        A & allocator() { return *this; }
+        F       & functor  ()       { return *this; }
+        F const & functor  () const { return *this; }
+        A       & allocator()       { return *this; }
+        A const & allocator() const { return *this; }
       };
 
-
-      typedef boost::aligned_storage<sizeof( void * ) * 2, sizeof( void * ) * 2>::type trivial_heap_storage_atom;
-
-      template<typename Functor>
+      template <typename Functor>
       struct functor_traits
       {
           BOOST_STATIC_CONSTANT
@@ -447,7 +452,7 @@
           BOOST_STATIC_CONSTANT
           (bool,
           hasDefaultAlignement =
-            alignment_of<Functor>::value == alignment_of<trivial_heap_storage_atom>::value);
+            alignment_of<Functor>::value <= alignment_of<double>::value);
       };
 
 
@@ -525,8 +530,8 @@
       struct manager_ptr
       {
       public:
-          static void       *       * functor_ptr( function_buffer       & buffer ) { return &buffer.obj_ptr; }
-          static void const * const * functor_ptr( function_buffer const & buffer ) { BF_ASSUME( buffer.obj_ptr ); return functor_ptr( const_cast<function_buffer &>( buffer ) ); }
+          static void       *       * functor_ptr( function_buffer       & buffer ) {                              return &buffer.obj_ptr; }
+          static void const * const * functor_ptr( function_buffer const & buffer ) { BF_ASSUME( buffer.obj_ptr ); return &buffer.obj_ptr; }
 
           template <typename Functor, typename Allocator>
           static void assign( Functor const & functor, function_buffer & out_buffer, Allocator )
@@ -537,7 +542,9 @@
 
           static void BF_FASTCALL_WORKAROUND clone( function_buffer const & in_buffer, function_buffer & out_buffer )
           {
-              return assign( *functor_ptr( in_buffer ), out_buffer, dummy_allocator() );
+		      //...zzz...even with BF_ASSUME MSVC still generates branching code...
+              //return assign( *functor_ptr( in_buffer ), out_buffer, dummy_allocator() );
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
           }
 
           static void BF_FASTCALL_WORKAROUND move( function_buffer & in_buffer, function_buffer & out_buffer )
@@ -633,8 +640,11 @@
 
           static void BF_FASTCALL_WORKAROUND destroy( function_buffer & buffer )
           {
+              BOOST_ASSERT( buffer.trivial_heap_obj.ptr  );
+              BOOST_ASSERT( buffer.trivial_heap_obj.size );
+
               trivial_allocator a;
-              a.deallocate( functor_ptr( buffer ) );
+              a.deallocate( static_cast<typename trivial_allocator::pointer>( functor_ptr( buffer ) ), buffer.trivial_heap_obj.size );
               //functor_ptr( buffer ) = 0;
           }
       };
@@ -722,18 +732,18 @@
               assign_aux<guard_t>( functor, out_buffer, source_allocator );
           }
 
-          static void clone( function_buffer const & in_buffer, function_buffer & out_buffer )
+          static void BF_FASTCALL_WORKAROUND clone( function_buffer const & in_buffer, function_buffer & out_buffer )
           {
               functor_and_allocator_t const & in_functor_and_allocator( *functor_ptr( in_buffer ) );
               return assign( in_functor_and_allocator.functor(), out_buffer, in_functor_and_allocator.allocator() );
           }
 
-          static void move( function_buffer & in_buffer, function_buffer & out_buffer )
+          static void BF_FASTCALL_WORKAROUND move( function_buffer & in_buffer, function_buffer & out_buffer )
           {
               manager_trivial_heap<OriginalAllocator>::move( in_buffer, out_buffer );
           }
 
-          static void destroy( function_buffer & buffer )
+          static void BF_FASTCALL_WORKAROUND destroy( function_buffer & buffer )
           {
               functor_and_allocator_t & in_functor_and_allocator( *functor_ptr( buffer ) );
 
@@ -741,10 +751,10 @@
               allocator_allocator_t allocator_allocator( in_functor_and_allocator.allocator() );
               wrapper_allocator_t   full_allocator     ( in_functor_and_allocator.allocator() );
 
-              original_allocator .destroy( &in_functor_and_allocator.functor  () );
-              allocator_allocator.destroy( &in_functor_and_allocator.allocator() );
+              original_allocator .destroy( original_allocator .address( in_functor_and_allocator.functor  () ) );
+              allocator_allocator.destroy( allocator_allocator.address( in_functor_and_allocator.allocator() ) );
 
-              full_allocator.deallocate( &in_functor_and_allocator );
+              full_allocator.deallocate( full_allocator.address( in_functor_and_allocator ) );
               //functor_ptr( buffer ) = 0;
           }
 
@@ -760,8 +770,8 @@
               allocator_allocator_t allocator_allocator( source_allocator );
 
               Guard                         p_placeholder          ( full_allocator.allocate( 1 ) );
-              Functor               * const p_functor_placeholder  ( p_placeholder                );
-              OriginalAllocator     * const p_allocator_placeholder( p_placeholder                );
+              Functor               * const p_functor_placeholder  ( get_pointer( p_placeholder ) );
+              OriginalAllocator     * const p_allocator_placeholder( get_pointer( p_placeholder ) );
 
               source_allocator   .construct( p_functor_placeholder  , functor          );
               allocator_allocator.construct( p_allocator_placeholder, source_allocator );
@@ -788,7 +798,13 @@
       template <typename Functor, typename Allocator>
       struct functor_manager<Functor, Allocator, true, false, false, true>
       {
-          typedef manager_trivial_heap<Allocator> type;
+          typedef typename mpl::if_
+          <
+            //...zzz...is_stateless<Allocator>,
+            is_empty<Allocator>,
+            manager_trivial_heap<         Allocator>,
+            manager_generic     <Functor, Allocator>
+          >::type type;
       };
 
       template <typename Functor, typename Allocator, bool defaultAligned>
@@ -955,23 +971,6 @@
 
       #endif // BOOST_FUNCTION_NO_RTTI
 
-
-/*    ALLOCATOR SUPPORT TEMPORARILY COMMENTED OUT
-          template<typename FunctionObj,typename Allocator>
-          void 
-          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
-                  wrapper_allocator_type;
-              typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
-              wrapper_allocator_type wrapper_allocator(a);
-              wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
-              wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
-              functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
-              functor.obj_ptr = new_f;
-          }
-*/
       };
 
       template <class Invoker, class Manager>
@@ -1070,7 +1069,12 @@
   class safe_mover;
 
 public:
-    function_base( detail::function::vtable const & vtable ) : pVTable( &vtable ) { }
+    function_base( detail::function::vtable const & vtable ) : pVTable( &vtable )
+    {
+        #ifdef _DEBUG
+            std::memset( &this->functor, 0, sizeof( this->functor ) );
+        #endif // _DEBUG
+    }
     ~function_base() { destroy(); }
 
   template <class EmptyHandler>
@@ -1157,13 +1161,14 @@
         emptyHandler,
         empty_handler_vtable,
         empty_handler_vtable, 
-        detail::function::fallocator<EmptyHandler>()
+        detail::function::fallocator<EmptyHandler>(),
+        mpl::false_()
       );
   }
 
 private: // Assignment from another boost function helpers.
   BF_NOINLINE
-  void assign_direct( function_base const & source )
+  void assign_boost_function_direct( function_base const & source )
   {
       source.pVTable->clone( source.functor, this->functor );
       pVTable = source.pVTable;
@@ -1171,24 +1176,24 @@
 
   template <class EmptyHandler>
   BF_NOINLINE
-  void assign_guarded( function_base const & source, detail::function::vtable const & empty_handler_vtable )
+  void assign_boost_function_guarded( function_base const & source, detail::function::vtable const & empty_handler_vtable )
   {
       this->destroy();
       cleaner<EmptyHandler> guard( *this, empty_handler_vtable );
-      assign_direct( source );
+      assign_boost_function_direct( source );
       guard.cancel();
   }
 
 protected:
   // Assignment from another boost function.
   template <bool direct, typename EmptyHandler, typename FunctionObj, typename Allocator>
-  typename enable_if<is_base_of<function_base, FunctionObj> >::type
-  assign
+  void assign
   (
-    FunctionObj const & f,
+    FunctionObj              const & f,
     detail::function::vtable const & functor_vtable,
     detail::function::vtable const & empty_handler_vtable,
-    Allocator
+    Allocator,
+    mpl::true_ /*assignment of an instance of the same boost::function<> instantiation*/
   )
   {
     BOOST_ASSERT( &functor_vtable == f.pVTable );
@@ -1197,23 +1202,23 @@
     {
         BOOST_ASSERT( &static_cast<function_base const &>( f ) != this );
         BOOST_ASSERT( this->pVTable == &empty_handler_vtable );
-        assign_direct( f );
+        assign_boost_function_direct( f );
     }
     else if( &static_cast<function_base const &>( f ) != this )
     {
-        assign_guarded<EmptyHandler>( f, empty_handler_vtable );
+        assign_boost_function_guarded<EmptyHandler>( f, empty_handler_vtable );
     }
   }
 
   // General actual assignment.
   template <bool direct, typename EmptyHandler, typename FunctionObj, typename Allocator>
-  typename disable_if<is_base_of<function_base, FunctionObj> >::type
-  assign
+  void assign
   (
-    FunctionObj const & f,
+    FunctionObj              const & f,
     detail::function::vtable const & functor_vtable,
     detail::function::vtable const & empty_handler_vtable,
-    Allocator
+    Allocator,
+    mpl::false_ /*generic assign*/
   );
 
   template <typename EmptyHandler, typename FunctionObj, typename Allocator>
@@ -1549,7 +1554,9 @@
     template <class FunctionPtr>
     inline bool has_empty_target( reference_wrapper<FunctionPtr> const * const f )
     {
-        return has_empty_target( f->get_pointer() );
+        //...zzz...return has_empty_target( f->get_pointer() );
+        BF_ASSUME( f->get_pointer() != 0 );
+        return f == 0;
     }
 
     template <class FunctionPtr>
@@ -1566,7 +1573,7 @@
     }
 
 #ifdef BOOST_MSVC // MSVC (9.0 SP1 and prior) cannot inline vararg functions
-    inline bool has_empty_target(const void*)
+    inline bool has_empty_target( void const * )
 #else
     inline bool has_empty_target(...)
 #endif
@@ -1599,13 +1606,13 @@
 
 //...zzz...here because of has_empty_target()...GCC & Clang are not lazy enough
 template <bool direct, typename EmptyHandler, typename FunctionObj, typename Allocator>
-typename disable_if<is_base_of<function_base, FunctionObj> >::type
-function_base::assign
+void function_base::assign
 (
     FunctionObj              const & f,
     detail::function::vtable const & functor_vtable,
     detail::function::vtable const & empty_handler_vtable,
-    Allocator                const   a
+    Allocator                const   a,
+    mpl::false_ /*generic assign*/
 )
 {
     using namespace detail::function;

Modified: sandbox/function/boost/function/function_template.hpp
==============================================================================
--- sandbox/function/boost/function/function_template.hpp	(original)
+++ sandbox/function/boost/function/function_template.hpp	2010-10-28 05:37:04 EDT (Thu, 28 Oct 2010)
@@ -137,6 +137,9 @@
   <
     typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
     class PolicyList
+    #if ( BOOST_FUNCTION_MAX_ARGS > 10 )
+        = default_policies //...zzz...this causes hoards of warnings...
+    #endif // BOOST_FUNCTION_MAX_ARGS > 10
   >
   class BOOST_FUNCTION_FUNCTION : public function_base
 
@@ -598,7 +601,8 @@
                 emptyHandler,
                 empty_handler_vtable(),
                 empty_handler_vtable(),
-                detail::function::fallocator<base_empty_handler>()
+                detail::function::fallocator<base_empty_handler>(),
+                mpl::false_() /*not assigning another boost::function*/
             );
             emptyHandler. BOOST_NESTED_TEMPLATE handle_empty_invoke<R>();
         }
@@ -610,7 +614,8 @@
                 stored_functor,
                 vtable_for_functor<StoredFunctorAllocator, ActualFunctor>( stored_functor ),
                 empty_handler_vtable(),
-                StoredFunctorAllocator( a )
+                StoredFunctorAllocator( a ),
+                is_base_of<BOOST_FUNCTION_FUNCTION, StoredFunctor>() /*are we assigning another boost::function*/
             );
         }
     }