#ifndef BOOST_STATECHART_FIFO_SCHEDULER_HPP_INCLUDED

 #define BOOST_STATECHART_FIFO_SCHEDULER_HPP_INCLUDED

 //////////////////////////////////////////////////////////////////////////////

 // Copyright 2002-2006 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/fifo_worker.hpp>

 #include <boost/statechart/processor_container.hpp>

 #include <boost/intrusive_ptr.hpp>

 #include <boost/noncopyable.hpp>

 #include <boost/config.hpp> // BOOST_HAS_THREADS

 namespace boost

 {

 namespace statechart

 {

 //////////////////////////////////////////////////////////////////////////////

 template<

   class FifoWorker = fifo_worker<>,

   class Allocator = std::allocator< void > >

 class fifo_scheduler : noncopyable

 {

   typedef processor_container<

     fifo_scheduler, typename FifoWorker::work_item, Allocator > container;

   public:

     //////////////////////////////////////////////////////////////////////////

     #ifdef BOOST_HAS_THREADS

     fifo_scheduler( bool waitOnEmptyQueue = false ) :

       worker_( waitOnEmptyQueue )

     {

     }

     #endif

     typedef typename container::processor_handle processor_handle;

     typedef typename container::processor_context processor_context;

     template< class Processor >

     processor_handle create_processor()

     {

       processor_handle result;

       work_item item =

         container_.template create_processor< Processor >( result, *this );

       worker_.queue_work_item( item );

       return result;

     }

     template< class Processor, typename Arg1 >

     processor_handle create_processor( Arg1 arg1 )

     {

       processor_handle result;

       work_item item = container_.template create_processor< Processor >(

         result, *this, arg1 );

       worker_.queue_work_item( item );

       return result;

     }

     template< class Processor, typename Arg1, typename Arg2 >

     processor_handle create_processor( Arg1 arg1, Arg2 arg2 )

     {

       processor_handle result;

       work_item item = container_.template create_processor< Processor >(

         result, *this, arg1, arg2 );

       worker_.queue_work_item( item );

       return result;

     }

     template< class Processor, typename Arg1, typename Arg2, typename Arg3 >

     processor_handle create_processor( Arg1 arg1, Arg2 arg2, Arg3 arg3 )

     {

       processor_handle result;

       work_item item = container_.template create_processor< Processor >(

         result, *this, arg1, arg2, arg3 );

       worker_.queue_work_item( item );

       return result;

     }

     template<

       class Processor, typename Arg1, typename Arg2,

       typename Arg3, typename Arg4 >

     processor_handle create_processor(

       Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4 )

     {

       processor_handle result;

       work_item item = container_.template create_processor< Processor >(

         result, *this, arg1, arg2, arg3, arg4 );

       worker_.queue_work_item( item );

       return result;

     }

     template<

       class Processor, typename Arg1, typename Arg2,

       typename Arg3, typename Arg4, typename Arg5 >

     processor_handle create_processor(

       Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5 )

     {

       processor_handle result;

       work_item item = container_.template create_processor< Processor >(

         result, *this, arg1, arg2, arg3, arg4, arg5 );

       worker_.queue_work_item( item );

       return result;

     }

     template<

       class Processor, typename Arg1, typename Arg2,

       typename Arg3, typename Arg4, typename Arg5, typename Arg6 >

     processor_handle create_processor(

       Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6 )

     {

       processor_handle result;

       work_item item = container_.template create_processor< Processor >(

         result, *this, arg1, arg2, arg3, arg4, arg5, arg6 );

       worker_.queue_work_item( item );

       return result;

     }

     void destroy_processor( const processor_handle & processor )

     {

       work_item item = container_.destroy_processor( processor );

       worker_.queue_work_item( item );

     }

     void initiate_processor( const processor_handle & processor )

     {

       work_item item = container_.initiate_processor( processor );

       worker_.queue_work_item( item );

     }

     void terminate_processor( const processor_handle & processor )

     {

       work_item item = container_.terminate_processor( processor );

       worker_.queue_work_item( item );

     }

     typedef intrusive_ptr< const event_base > event_ptr_type;

     void queue_event(

       const processor_handle & processor, const event_ptr_type & pEvent )

     {

       work_item item = container_.queue_event( processor, pEvent );

       worker_.queue_work_item( item );

     }

     typedef typename FifoWorker::work_item work_item;

     // We take a non-const reference so that we can move (i.e. swap) the item

     // into the queue, what avoids copying the (possibly heap-allocated)

     // implementation object inside work_item.

     void queue_work_item( work_item & item )

     {

       worker_.queue_work_item( item );

     }

     // Convenience overload so that temporary objects can be passed directly

     // instead of having to create a work_item object first. Under most

     // circumstances, this will lead to one unnecessary copy of the

     // function implementation object.

     void queue_work_item( const work_item & item )

     {

       worker_.queue_work_item( item );

     }

     void terminate()

     {

       worker_.terminate();

     }

     // Is not mutex-protected! Must only be called from the thread that also

     // calls operator().

     bool terminated() const

     {

       return worker_.terminated();

     }

     unsigned long operator()( unsigned long maxEventCount = 0 )

     {

       return worker_( maxEventCount );

     }

   private:

     //////////////////////////////////////////////////////////////////////////

     container container_;

     FifoWorker worker_;

 };

 } // namespace statechart

 } // namespace boost

 #endif