ACT.hpp

Go to the documentation of this file.

// 
// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of GNU Cygnal.
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#pragma once
#ifndef __ACT_hpp___
#define __ACT_hpp___

#include <boost/functional.hpp>
#include <boost/shared_ptr.hpp>
using boost::shared_ptr ;

namespace ACT {
        //-------------------------
        class ACT_State
        {
        public:
                enum state {
                        Ready,
                        Would_Block,
                        Completed,
                        Bad
                } ;

        private:
                state x ;

        public:
                ACT_State( state x ) : x( x ) {} ;

                ACT_State & operator=( state y ) { x = y ; return * this ; }

                inline bool ready() const { return x == Ready ; }

                inline bool would_block() const { return x == Would_Block ; }

                inline bool completed() const { return x == Completed ; }

                inline bool bad() const { return x == Bad ; }

                inline bool working() const { return x <= Would_Block ; }
        } ;

        //-------------------------
        // Forward
        class wakeup_listener ;
        //-------------------------
        class basic_act {
                ACT_State the_state ;

        protected:
                basic_act() 
                        : the_state( ACT_State::Ready )
                {}

                inline ACT_State set_ready() { return the_state = ACT_State::Ready ; }

                inline ACT_State set_would_block() { return the_state = ACT_State::Would_Block ; }

                inline ACT_State set_completed() { return the_state = ACT_State::Completed ; }

                inline ACT_State set_bad() { return the_state = ACT_State::Bad ; }

                inline ACT_State set_state( ACT_State x ) { return the_state = x ; }

        public:
                inline ACT_State internal_state() { return the_state ; }

                inline bool ready() const { return the_state.ready() ; }

                inline bool would_block() const { return the_state.would_block() ; }

                inline bool working() const { return the_state.working() ; }

                inline bool completed() const { return the_state.completed() ; }

                inline bool bad() const { return the_state.bad() ; }

                virtual ACT_State operator()( void ) =0 ;

                virtual ACT_State operator()( wakeup_listener * ) =0 ;

        } ;

        //-------------------------
        class simple_act
                : public basic_act
        {
        protected:
                virtual ACT_State run( void ) =0 ;

        public:
                inline ACT_State operator()( void )
                {
                        if ( ! working() ) return internal_state() ;
                        return run() ;
                }

                inline ACT_State operator()( wakeup_listener * )
                {
                        return operator()() ;
                }
        } ;

        //-------------------------
        class autonomous_act
                : public basic_act
        {
                friend class act ;

        protected:
                virtual ACT_State run( wakeup_listener * ) =0 ;

        public:
                inline ACT_State operator()( wakeup_listener * w )
                {
                        if ( ! working() ) return internal_state() ;
                        return run( w ) ;
                }

                inline ACT_State operator()() { return operator()( 0 ) ; }
        } ;

        //-------------------------
        class act
        {
                shared_ptr< basic_act > the_body ;

        public:
                act( basic_act * the_body ) ;

                act( shared_ptr< basic_act > ) ;

                ~act() ;

                shared_ptr< basic_act > the_underlying_act()
                {
                        return the_body ;
                }

                ACT_State operator()( wakeup_listener * x ) {
                        if ( working() ) {
                                return the_body -> operator()( x ) ;
                        }
                        return the_body -> internal_state() ;
                }

                inline bool working() const { return the_body -> working() ; }

                inline bool completed() const { return the_body -> completed() ; }

                inline bool bad() const { return the_body -> bad() ; }
        } ;

} // end of namespace ACT

#endif  // end of inclusion protection

---