Added boost header

test/external/boost/statechart/processor_container.hpp

@@ -0,0 +1,445 @@
+#ifndef BOOST_STATECHART_PROCESSOR_CONTAINER_HPP_INCLUDED
+#define BOOST_STATECHART_PROCESSOR_CONTAINER_HPP_INCLUDED
+//////////////////////////////////////////////////////////////////////////////
+// Copyright 2002-2008 Andreas Huber Doenni
+// Distributed under the Boost Software License, Version 1.0. (See accompany-
+// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//////////////////////////////////////////////////////////////////////////////
+
+
+
+#include <boost/statechart/event_base.hpp>
+#include <boost/statechart/event_processor.hpp>
+
+#include <boost/assert.hpp>
+#include <boost/ref.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/config.hpp> // BOOST_INTEL
+
+#include <boost/detail/workaround.hpp>
+#include <boost/detail/allocator_utilities.hpp>
+
+#include <set>
+#include <memory>   // std::allocator, std::auto_ptr
+
+
+
+namespace boost
+{
+namespace statechart
+{
+namespace detail
+{
+  template<bool IsReferenceWrapper>
+  struct unwrap_impl
+  {
+    template< typename T >
+    struct apply { typedef T type; };
+  };
+
+  template<>
+  struct unwrap_impl<true>
+  {
+    template< typename T >
+    struct apply { typedef typename T::type & type; };
+  };
+
+  template<typename T>
+  struct unwrap
+  {
+    typedef typename unwrap_impl<
+      is_reference_wrapper< T >::value >::template apply< T >::type type;
+  };
+}
+
+
+template<
+  class Scheduler,
+  class WorkItem,
+  class Allocator = std::allocator< void > >
+class processor_container : noncopyable
+{
+  typedef event_processor< Scheduler > processor_base_type;
+  typedef std::auto_ptr< processor_base_type > processor_holder_type;
+  typedef shared_ptr< processor_holder_type > processor_holder_ptr_type;
+
+  public:
+    //////////////////////////////////////////////////////////////////////////
+    typedef weak_ptr< processor_holder_type > processor_handle;
+
+    class processor_context
+    {
+        processor_context(
+          Scheduler & scheduler, const processor_handle & handle
+        ) :
+          scheduler_( scheduler ),
+          handle_( handle )
+        {
+        }
+
+      #if BOOST_WORKAROUND( BOOST_INTEL, BOOST_TESTED_AT( 800 ) )
+      public:
+      // for some reason Intel 8.0 seems to think that the following functions
+      // are inaccessible from event_processor<>::event_processor
+      #endif
+
+        Scheduler & my_scheduler() const { return scheduler_; }
+        const processor_handle & my_handle() const { return handle_; }
+
+      #if BOOST_WORKAROUND( BOOST_INTEL, BOOST_TESTED_AT( 800 ) )
+      private:
+      #endif
+
+        // avoids C4512 (assignment operator could not be generated)
+        processor_context & operator=( const processor_context & );
+
+        Scheduler & scheduler_;
+        const processor_handle handle_;
+
+        friend class processor_container;
+        friend class event_processor< Scheduler >;
+    };
+
+    template< class Processor >
+    WorkItem create_processor( processor_handle & handle, Scheduler & scheduler )
+    {
+      processor_holder_ptr_type pProcessor = make_processor_holder();
+      handle = pProcessor;
+      typedef void ( processor_container::*impl_fun_ptr )(
+        const processor_holder_ptr_type &, const processor_context & );
+      impl_fun_ptr pImpl =
+        &processor_container::template create_processor_impl0< Processor >;
+      return WorkItem(
+        boost::bind( pImpl, this, pProcessor,
+          processor_context( scheduler, handle ) ),
+        Allocator() );
+    }
+
+    template< class Processor, typename Arg1 >
+    WorkItem create_processor(
+      processor_handle & handle, Scheduler & scheduler, Arg1 arg1 )
+    {
+      processor_holder_ptr_type pProcessor = make_processor_holder();
+      handle = pProcessor;
+      typedef typename detail::unwrap< Arg1 >::type arg1_type;
+      typedef void ( processor_container::*impl_fun_ptr )(
+        const processor_holder_ptr_type &, const processor_context &,
+        arg1_type );
+      impl_fun_ptr pImpl =
+        &processor_container::template create_processor_impl1<
+          Processor, arg1_type >;
+      return WorkItem(
+        boost::bind( pImpl, this, pProcessor, processor_context( scheduler, handle ),
+          arg1 ),
+        Allocator() );
+    }
+
+    template< class Processor, typename Arg1, typename Arg2 >
+    WorkItem create_processor(
+      processor_handle & handle, Scheduler & scheduler, Arg1 arg1, Arg2 arg2 )
+    {
+      processor_holder_ptr_type pProcessor = make_processor_holder();
+      handle = pProcessor;
+      typedef typename detail::unwrap< Arg1 >::type arg1_type;
+      typedef typename detail::unwrap< Arg2 >::type arg2_type;
+      typedef void ( processor_container::*impl_fun_ptr )(
+        const processor_holder_ptr_type &, const processor_context &,
+         arg1_type, arg2_type );
+      impl_fun_ptr pImpl =
+        &processor_container::template create_processor_impl2<
+          Processor, arg1_type, arg2_type >;
+      return WorkItem(
+        boost::bind( pImpl, this, pProcessor, processor_context( scheduler, handle ),
+          arg1, arg2 ),
+        Allocator() );
+    }
+
+    template< class Processor, typename Arg1, typename Arg2, typename Arg3 >
+    WorkItem create_processor(
+      processor_handle & handle, Scheduler & scheduler,
+      Arg1 arg1, Arg2 arg2, Arg3 arg3 )
+    {
+      processor_holder_ptr_type pProcessor = make_processor_holder();
+      handle = pProcessor;
+      typedef typename detail::unwrap< Arg1 >::type arg1_type;
+      typedef typename detail::unwrap< Arg2 >::type arg2_type;
+      typedef typename detail::unwrap< Arg3 >::type arg3_type;
+      typedef void ( processor_container::*impl_fun_ptr )(
+        const processor_holder_ptr_type &, const processor_context &,
+        arg1_type, arg2_type, arg3_type );
+      impl_fun_ptr pImpl =
+        &processor_container::template create_processor_impl3<
+          Processor, arg1_type, arg2_type, arg3_type >;
+      return WorkItem(
+        boost::bind( pImpl, this, pProcessor, processor_context( scheduler, handle ),
+          arg1, arg2, arg3 ),
+        Allocator() );
+    }
+
+    template<
+      class Processor, typename Arg1, typename Arg2,
+      typename Arg3, typename Arg4 >
+    WorkItem create_processor(
+      processor_handle & handle, Scheduler & scheduler,
+      Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4 )
+    {
+      processor_holder_ptr_type pProcessor = make_processor_holder();
+      handle = pProcessor;
+      typedef typename detail::unwrap< Arg1 >::type arg1_type;
+      typedef typename detail::unwrap< Arg2 >::type arg2_type;
+      typedef typename detail::unwrap< Arg3 >::type arg3_type;
+      typedef typename detail::unwrap< Arg4 >::type arg4_type;
+      typedef void ( processor_container::*impl_fun_ptr )(
+        const processor_holder_ptr_type &, const processor_context &,
+        arg1_type, arg2_type, arg3_type, arg4_type );
+      impl_fun_ptr pImpl =
+        &processor_container::template create_processor_impl4<
+          Processor, arg1_type, arg2_type, arg3_type, arg4_type >;
+      return WorkItem(
+        boost::bind( pImpl, this, pProcessor, processor_context( scheduler, handle ),
+          arg1, arg2, arg3, arg4 ),
+        Allocator() );
+    }
+
+    template<
+      class Processor, typename Arg1, typename Arg2,
+      typename Arg3, typename Arg4, typename Arg5 >
+    WorkItem create_processor(
+      processor_handle & handle, Scheduler & scheduler,
+      Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5 )
+    {
+      processor_holder_ptr_type pProcessor = make_processor_holder();
+      handle = pProcessor;
+      typedef typename detail::unwrap< Arg1 >::type arg1_type;
+      typedef typename detail::unwrap< Arg2 >::type arg2_type;
+      typedef typename detail::unwrap< Arg3 >::type arg3_type;
+      typedef typename detail::unwrap< Arg4 >::type arg4_type;
+      typedef typename detail::unwrap< Arg5 >::type arg5_type;
+      typedef void ( processor_container::*impl_fun_ptr )(
+        const processor_holder_ptr_type &, const processor_context &,
+        arg1_type, arg2_type, arg3_type, arg4_type, arg5_type );
+      impl_fun_ptr pImpl =
+        &processor_container::template create_processor_impl5<
+          Processor, arg1_type, arg2_type, arg3_type, arg4_type, arg5_type >;
+      return WorkItem(
+        boost::bind( pImpl, this, pProcessor, processor_context( scheduler, handle ),
+          arg1, arg2, arg3, arg4, arg5 ),
+        Allocator() );
+    }
+
+    template<
+      class Processor, typename Arg1, typename Arg2,
+      typename Arg3, typename Arg4, typename Arg5, typename Arg6 >
+    WorkItem create_processor(
+      processor_handle & handle, Scheduler & scheduler,
+      Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6 )
+    {
+      processor_holder_ptr_type pProcessor = make_processor_holder();
+      handle = pProcessor;
+      typedef typename detail::unwrap< Arg1 >::type arg1_type;
+      typedef typename detail::unwrap< Arg2 >::type arg2_type;
+      typedef typename detail::unwrap< Arg3 >::type arg3_type;
+      typedef typename detail::unwrap< Arg4 >::type arg4_type;
+      typedef typename detail::unwrap< Arg5 >::type arg5_type;
+      typedef typename detail::unwrap< Arg6 >::type arg6_type;
+      typedef void ( processor_container::*impl_fun_ptr )(
+        const processor_holder_ptr_type &, const processor_context &,
+        arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type );
+      impl_fun_ptr pImpl =
+        &processor_container::template create_processor_impl6<
+          Processor,
+          arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type >;
+      return WorkItem(
+        boost::bind( pImpl, this, pProcessor, processor_context( scheduler, handle ),
+          arg1, arg2, arg3, arg4, arg5, arg6 ),
+        Allocator() );
+    }
+
+    WorkItem destroy_processor( const processor_handle & processor )
+    {
+      return WorkItem(
+        boost::bind( &processor_container::destroy_processor_impl, this, processor ),
+        Allocator() );
+    }
+
+    WorkItem initiate_processor( const processor_handle & processor )
+    {
+      return WorkItem(
+        boost::bind( &processor_container::initiate_processor_impl, this,
+          processor ),
+        Allocator() );
+    }
+
+    WorkItem terminate_processor( const processor_handle & processor )
+    {
+      return WorkItem(
+        boost::bind( &processor_container::terminate_processor_impl, this,
+          processor ),
+        Allocator() );
+    }
+
+    typedef intrusive_ptr< const event_base > event_ptr_type;
+
+    WorkItem queue_event(
+      const processor_handle & processor, const event_ptr_type & pEvent )
+    {
+      BOOST_ASSERT( pEvent.get() != 0 );
+
+      return WorkItem(
+        boost::bind( &processor_container::queue_event_impl, this, processor,
+          pEvent ),
+        Allocator() );
+    }
+
+  private:
+    //////////////////////////////////////////////////////////////////////////
+    processor_holder_ptr_type make_processor_holder()
+    {
+      return processor_holder_ptr_type( new processor_holder_type() );
+    }
+
+    template< class Processor >
+    void create_processor_impl0(
+      const processor_holder_ptr_type & pProcessor,
+      const processor_context & context )
+    {
+      processorSet_.insert( pProcessor );
+      processor_holder_type holder( new Processor( context ) );
+      *pProcessor = holder;
+    }
+
+    template< class Processor, typename Arg1 >
+    void create_processor_impl1(
+      const processor_holder_ptr_type & pProcessor,
+      const processor_context & context, Arg1 arg1 )
+    {
+      processorSet_.insert( pProcessor );
+      processor_holder_type holder( new Processor( context, arg1 ) );
+      *pProcessor = holder;
+    }
+
+    template< class Processor, typename Arg1, typename Arg2 >
+    void create_processor_impl2(
+      const processor_holder_ptr_type & pProcessor,
+      const processor_context & context, Arg1 arg1, Arg2 arg2 )
+    {
+      processorSet_.insert( pProcessor );
+      processor_holder_type holder( new Processor( context, arg1, arg2 ) );
+      *pProcessor = holder;
+    }
+
+    template< class Processor, typename Arg1, typename Arg2, typename Arg3 >
+    void create_processor_impl3(
+      const processor_holder_ptr_type & pProcessor,
+      const processor_context & context, Arg1 arg1, Arg2 arg2, Arg3 arg3 )
+    {
+      processorSet_.insert( pProcessor );
+      processor_holder_type holder(
+        new Processor( context, arg1, arg2, arg3 ) );
+      *pProcessor = holder;
+    }
+
+    template<
+      class Processor, typename Arg1, typename Arg2,
+      typename Arg3, typename Arg4 >
+    void create_processor_impl4(
+      const processor_holder_ptr_type & pProcessor,
+      const processor_context & context,
+      Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4 )
+    {
+      processorSet_.insert( pProcessor );
+      processor_holder_type holder(
+        new Processor( context, arg1, arg2, arg3, arg4 ) );
+      *pProcessor = holder;
+    }
+
+    template<
+      class Processor, typename Arg1, typename Arg2,
+      typename Arg3, typename Arg4, typename Arg5 >
+    void create_processor_impl5(
+      const processor_holder_ptr_type & pProcessor,
+      const processor_context & context,
+      Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5 )
+    {
+      processorSet_.insert( pProcessor );
+      processor_holder_type holder(
+        new Processor( context, arg1, arg2, arg3, arg4, arg5 ) );
+      *pProcessor = holder;
+    }
+
+    template<
+      class Processor, typename Arg1, typename Arg2,
+      typename Arg3, typename Arg4, typename Arg5, typename Arg6 >
+    void create_processor_impl6(
+      const processor_holder_ptr_type & pProcessor,
+      const processor_context & context,
+      Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6 )
+    {
+      processorSet_.insert( pProcessor );
+      processor_holder_type holder(
+        new Processor( context, arg1, arg2, arg3, arg4, arg5, arg6 ) );
+      *pProcessor = holder;
+    }
+
+    void destroy_processor_impl( const processor_handle & processor )
+    {
+      const processor_holder_ptr_type pProcessor = processor.lock();
+
+      if ( pProcessor != 0 )
+      {
+        processorSet_.erase( pProcessor );
+      }
+    }
+
+    void initiate_processor_impl( const processor_handle & processor )
+    {
+      const processor_holder_ptr_type pProcessor = processor.lock();
+
+      if ( pProcessor != 0 )
+      {
+        ( *pProcessor )->initiate();
+      }
+    }
+
+    void terminate_processor_impl( const processor_handle & processor )
+    {
+      const processor_holder_ptr_type pProcessor = processor.lock();
+
+      if ( pProcessor != 0 )
+      {
+        ( *pProcessor )->terminate();
+      }
+    }
+
+    void queue_event_impl(
+      const processor_handle & processor, const event_ptr_type & pEvent )
+    {
+      const processor_holder_ptr_type pProcessor = processor.lock();
+
+      if ( pProcessor != 0 )
+      {
+        ( *pProcessor )->process_event( *pEvent );
+      }
+    }
+
+    typedef std::set< 
+      processor_holder_ptr_type, 
+      std::less< processor_holder_ptr_type >,
+      typename boost::detail::allocator::rebind_to<
+        Allocator, processor_holder_ptr_type >::type
+    > event_processor_set_type;
+
+    event_processor_set_type processorSet_;
+};
+
+
+} // namespace statechart
+} // namespace boost
+
+
+
+#endif