sl@0: #ifndef BOOST_STATECHART_FIFO_SCHEDULER_HPP_INCLUDED
sl@0: #define BOOST_STATECHART_FIFO_SCHEDULER_HPP_INCLUDED
sl@0: //////////////////////////////////////////////////////////////////////////////
sl@0: // Copyright 2002-2006 Andreas Huber Doenni
sl@0: // Distributed under the Boost Software License, Version 1.0. (See accompany-
sl@0: // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
sl@0: //////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: 
sl@0: 
sl@0: #include <boost/statechart/event_base.hpp>
sl@0: #include <boost/statechart/fifo_worker.hpp>
sl@0: #include <boost/statechart/processor_container.hpp>
sl@0: 
sl@0: #include <boost/intrusive_ptr.hpp>
sl@0: #include <boost/noncopyable.hpp>
sl@0: #include <boost/config.hpp> // BOOST_HAS_THREADS
sl@0: 
sl@0: 
sl@0: 
sl@0: namespace boost
sl@0: {
sl@0: namespace statechart
sl@0: {
sl@0: 
sl@0: 
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////
sl@0: template<
sl@0:   class FifoWorker = fifo_worker<>,
sl@0:   class Allocator = std::allocator< void > >
sl@0: class fifo_scheduler : noncopyable
sl@0: {
sl@0:   typedef processor_container<
sl@0:     fifo_scheduler, typename FifoWorker::work_item, Allocator > container;
sl@0:   public:
sl@0:     //////////////////////////////////////////////////////////////////////////
sl@0:     #ifdef BOOST_HAS_THREADS
sl@0:     fifo_scheduler( bool waitOnEmptyQueue = false ) :
sl@0:       worker_( waitOnEmptyQueue )
sl@0:     {
sl@0:     }
sl@0:     #endif
sl@0: 
sl@0:     typedef typename container::processor_handle processor_handle;
sl@0:     typedef typename container::processor_context processor_context;
sl@0: 
sl@0:     template< class Processor >
sl@0:     processor_handle create_processor()
sl@0:     {
sl@0:       processor_handle result;
sl@0:       work_item item =
sl@0:         container_.template create_processor< Processor >( result, *this );
sl@0:       worker_.queue_work_item( item );
sl@0:       return result;
sl@0:     }
sl@0: 
sl@0:     template< class Processor, typename Arg1 >
sl@0:     processor_handle create_processor( Arg1 arg1 )
sl@0:     {
sl@0:       processor_handle result;
sl@0:       work_item item = container_.template create_processor< Processor >(
sl@0:         result, *this, arg1 );
sl@0:       worker_.queue_work_item( item );
sl@0:       return result;
sl@0:     }
sl@0: 
sl@0:     template< class Processor, typename Arg1, typename Arg2 >
sl@0:     processor_handle create_processor( Arg1 arg1, Arg2 arg2 )
sl@0:     {
sl@0:       processor_handle result;
sl@0:       work_item item = container_.template create_processor< Processor >(
sl@0:         result, *this, arg1, arg2 );
sl@0:       worker_.queue_work_item( item );
sl@0:       return result;
sl@0:     }
sl@0: 
sl@0:     template< class Processor, typename Arg1, typename Arg2, typename Arg3 >
sl@0:     processor_handle create_processor( Arg1 arg1, Arg2 arg2, Arg3 arg3 )
sl@0:     {
sl@0:       processor_handle result;
sl@0:       work_item item = container_.template create_processor< Processor >(
sl@0:         result, *this, arg1, arg2, arg3 );
sl@0:       worker_.queue_work_item( item );
sl@0:       return result;
sl@0:     }
sl@0: 
sl@0:     template<
sl@0:       class Processor, typename Arg1, typename Arg2,
sl@0:       typename Arg3, typename Arg4 >
sl@0:     processor_handle create_processor(
sl@0:       Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4 )
sl@0:     {
sl@0:       processor_handle result;
sl@0:       work_item item = container_.template create_processor< Processor >(
sl@0:         result, *this, arg1, arg2, arg3, arg4 );
sl@0:       worker_.queue_work_item( item );
sl@0:       return result;
sl@0:     }
sl@0: 
sl@0:     template<
sl@0:       class Processor, typename Arg1, typename Arg2,
sl@0:       typename Arg3, typename Arg4, typename Arg5 >
sl@0:     processor_handle create_processor(
sl@0:       Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5 )
sl@0:     {
sl@0:       processor_handle result;
sl@0:       work_item item = container_.template create_processor< Processor >(
sl@0:         result, *this, arg1, arg2, arg3, arg4, arg5 );
sl@0:       worker_.queue_work_item( item );
sl@0:       return result;
sl@0:     }
sl@0: 
sl@0:     template<
sl@0:       class Processor, typename Arg1, typename Arg2,
sl@0:       typename Arg3, typename Arg4, typename Arg5, typename Arg6 >
sl@0:     processor_handle create_processor(
sl@0:       Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6 )
sl@0:     {
sl@0:       processor_handle result;
sl@0:       work_item item = container_.template create_processor< Processor >(
sl@0:         result, *this, arg1, arg2, arg3, arg4, arg5, arg6 );
sl@0:       worker_.queue_work_item( item );
sl@0:       return result;
sl@0:     }
sl@0: 
sl@0:     void destroy_processor( const processor_handle & processor )
sl@0:     {
sl@0:       work_item item = container_.destroy_processor( processor );
sl@0:       worker_.queue_work_item( item );
sl@0:     }
sl@0: 
sl@0:     void initiate_processor( const processor_handle & processor )
sl@0:     {
sl@0:       work_item item = container_.initiate_processor( processor );
sl@0:       worker_.queue_work_item( item );
sl@0:     }
sl@0: 
sl@0:     void terminate_processor( const processor_handle & processor )
sl@0:     {
sl@0:       work_item item = container_.terminate_processor( processor );
sl@0:       worker_.queue_work_item( item );
sl@0:     }
sl@0: 
sl@0:     typedef intrusive_ptr< const event_base > event_ptr_type;
sl@0: 
sl@0:     void queue_event(
sl@0:       const processor_handle & processor, const event_ptr_type & pEvent )
sl@0:     {
sl@0:       work_item item = container_.queue_event( processor, pEvent );
sl@0:       worker_.queue_work_item( item );
sl@0:     }
sl@0: 
sl@0:     typedef typename FifoWorker::work_item work_item;
sl@0: 
sl@0:     // We take a non-const reference so that we can move (i.e. swap) the item
sl@0:     // into the queue, what avoids copying the (possibly heap-allocated)
sl@0:     // implementation object inside work_item.
sl@0:     void queue_work_item( work_item & item )
sl@0:     {
sl@0:       worker_.queue_work_item( item );
sl@0:     }
sl@0: 
sl@0:     // Convenience overload so that temporary objects can be passed directly
sl@0:     // instead of having to create a work_item object first. Under most
sl@0:     // circumstances, this will lead to one unnecessary copy of the
sl@0:     // function implementation object.
sl@0:     void queue_work_item( const work_item & item )
sl@0:     {
sl@0:       worker_.queue_work_item( item );
sl@0:     }
sl@0: 
sl@0:     void terminate()
sl@0:     {
sl@0:       worker_.terminate();
sl@0:     }
sl@0: 
sl@0:     // Is not mutex-protected! Must only be called from the thread that also
sl@0:     // calls operator().
sl@0:     bool terminated() const
sl@0:     {
sl@0:       return worker_.terminated();
sl@0:     }
sl@0: 
sl@0:     unsigned long operator()( unsigned long maxEventCount = 0 )
sl@0:     {
sl@0:       return worker_( maxEventCount );
sl@0:     }
sl@0: 
sl@0:   private:
sl@0:     //////////////////////////////////////////////////////////////////////////
sl@0:     container container_;
sl@0:     FifoWorker worker_;
sl@0: };
sl@0: 
sl@0: 
sl@0: 
sl@0: } // namespace statechart
sl@0: } // namespace boost
sl@0: 
sl@0: 
sl@0: 
sl@0: #endif