Stomp_sm.h

#ifndef _H_STOMP_SM
#define _H_STOMP_SM

/*
 * ex: set ro:
 * DO NOT EDIT.
 * generated by smc (http://smc.sourceforge.net/)
 * from file : Stomp_sm.sm
 */


#define SMC_USES_IOSTREAMS

#include <statemap.h>

namespace STOMP
{
    // Forward declarations.
    class StompFSM_map;
    class StompFSM_map_Disconnected;
    class StompFSM_map_SocketConnected;
    class StompFSM_map_Ready;
    class StompFSM_map_SendingAck;
    class StompFSM_map_Disconnecting;
    class StompFSM_map_Default;
    class PocoStompState;
    class StompContext;
    class PocoStomp;

    class PocoStompState :
        public statemap::State
    {
    public:

        PocoStompState(const char *name, int stateId)
        : statemap::State(name, stateId)
        {};

        virtual void Entry(StompContext&) {};
        virtual void Exit(StompContext&) {};

        virtual void ack_received(StompContext& context, PFrame _frame);
        virtual void receive_frame(StompContext& context, PFrame _frame);
        virtual void send_frame(StompContext& context, PFrame _frame);
        virtual void socket_connected(StompContext& context);
        virtual void socket_disconnected(StompContext& context);
        virtual void timeout(StompContext& context);
        virtual void timeout(StompContext& context, PocoStompState* waitingfor);

    protected:

        virtual void Default(StompContext& context);
    };

    class StompFSM_map
    {
    public:

        static StompFSM_map_Disconnected Disconnected;
        static StompFSM_map_SocketConnected SocketConnected;
        static StompFSM_map_Ready Ready;
        static StompFSM_map_SendingAck SendingAck;
        static StompFSM_map_Disconnecting Disconnecting;
    };

    class StompFSM_map_Default :
        public PocoStompState
    {
    public:

        StompFSM_map_Default(const char *name, int stateId)
        : PocoStompState(name, stateId)
        {};

    };

    class StompFSM_map_Disconnected :
        public StompFSM_map_Default
    {
    public:
        StompFSM_map_Disconnected(const char *name, int stateId)
        : StompFSM_map_Default(name, stateId)
        {};

        void socket_connected(StompContext& context);
        void socket_disconnected(StompContext& context);
    };

    class StompFSM_map_SocketConnected :
        public StompFSM_map_Default
    {
    public:
        StompFSM_map_SocketConnected(const char *name, int stateId)
        : StompFSM_map_Default(name, stateId)
        {};

        void send_frame(StompContext& context, PFrame _frame);
        void socket_disconnected(StompContext& context);
    };

    class StompFSM_map_Ready :
        public StompFSM_map_Default
    {
    public:
        StompFSM_map_Ready(const char *name, int stateId)
        : StompFSM_map_Default(name, stateId)
        {};

        void receive_frame(StompContext& context, PFrame _frame);
        void send_frame(StompContext& context, PFrame _frame);
        void socket_disconnected(StompContext& context);
        void timeout(StompContext& context);
    };

    class StompFSM_map_SendingAck :
        public StompFSM_map_Default
    {
    public:
        StompFSM_map_SendingAck(const char *name, int stateId)
        : StompFSM_map_Default(name, stateId)
        {};

        void send_frame(StompContext& context, PFrame _frame);
    };

    class StompFSM_map_Disconnecting :
        public StompFSM_map_Default
    {
    public:
        StompFSM_map_Disconnecting(const char *name, int stateId)
        : StompFSM_map_Default(name, stateId)
        {};

        void ack_received(StompContext& context, PFrame _frame);
        void timeout(StompContext& context, PocoStompState* waitingfor);
    };

    class StompContext :
        public statemap::FSMContext
    {
    public:

        StompContext(PocoStomp& owner)
        : FSMContext(StompFSM_map::Disconnected),
          _owner(owner)
        {};

        StompContext(PocoStomp& owner, const statemap::State& state)
        : FSMContext(state),
          _owner(owner)
        {};

        virtual void enterStartState()
        {
            getState().Entry(*this);
            return;
        }

        PocoStomp& getOwner() const
        {
            return (_owner);
        };

        PocoStompState& getState() const
        {
            if (_state == NULL)
            {
                throw statemap::StateUndefinedException();
            }

            return (dynamic_cast<PocoStompState&>(*_state));
        };

        void ack_received(PFrame _frame)
        {
            (getState()).ack_received(*this, _frame);
        };

        void receive_frame(PFrame _frame)
        {
            (getState()).receive_frame(*this, _frame);
        };

        void send_frame(PFrame _frame)
        {
            (getState()).send_frame(*this, _frame);
        };

        void socket_connected()
        {
            (getState()).socket_connected(*this);
        };

        void socket_disconnected()
        {
            (getState()).socket_disconnected(*this);
        };

        void timeout()
        {
            (getState()).timeout(*this);
        };

        void timeout(PocoStompState* waitingfor)
        {
            (getState()).timeout(*this, waitingfor);
        };

    private:

        PocoStomp& _owner;
    };
}


/*
 * Local variables:
 *  buffer-read-only: t
 * End:
 */

#endif // _H_STOMP_SM