User Manual, Developers Guide and API Documentation

FSM.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 5, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef WNS_FSM_FSM_HPP
#define WNS_FSM_FSM_HPP

#include "FSMConfigCreator.hpp"

#include <WNS/StaticFactory.hpp>
#include <WNS/TypeInfo.hpp>
#include <WNS/Assure.hpp>
#include <WNS/SmartPtr.hpp>
#include <WNS/logger/Logger.hpp>
#include <WNS/pyconfig/Parser.hpp>

#include <string>

#include <iostream>

namespace wns { namespace fsm {
    template <typename SIGNALS, typename VARIABLES>
    class FSM
    {
    public:
        typedef VARIABLES VariablesType;

        class StateInterface :
            virtual public SIGNALS
        {
        private:
            template <class> friend class wns::fsm::FSMConfigCreator;

            typedef FSM<SIGNALS, VARIABLES> FSMType;

        public:
            explicit
            StateInterface(FSMType* _fsm, const std::string& _stateName) :
                fsm(_fsm),
                stateName(_stateName)
            {}

            virtual void
            initState()
            {}

            virtual void
            exitState()
            {}

            std::string
            getStateName() const
            {
                return stateName;
            }

            VariablesType&
            vars()
            {
                return getFSM()->getVariables();
            }

        protected:
            virtual FSMType*
            getFSM() const
            {
                return fsm;
            }

        private:
            FSMType* fsm;

            std::string stateName;
        };

        explicit
        FSM(const VariablesType& v) :
            currentState(NULL),
            variables(v),
            logger("WNS", TypeInfo::create(*this).toString()),
            stateCreated(false)
        {}

        virtual
        ~FSM()
        {
        }

    public:
        template <typename NEWSTATE>
        StateInterface*
        createState()
        {
            assure(!stateCreated, "A new state has been created already.");

            stateCreated = true;
            return new NEWSTATE(this);
        }

    private:
        typedef FSMConfigCreator<StateInterface> StateCreator;
        typedef wns::StaticFactory<StateCreator> StateFactory;

    public:
        StateInterface*
        createState(const std::string& stateName)
        {
            if (currentState && currentState->getStateName() == stateName)
                return currentState;

            assure(!stateCreated, "A new state has been created already.");

            stateCreated = true;
            return StateFactory::creator(stateName)
                ->create(this);
        }

        VariablesType&
        getVariables()
        {
            return variables;
        }

        std::string
        getStateName() const
        {
            return getState()->getStateName();
        }

        void
        replaceState(SIGNALS* newState)
        {
            assureType(newState, StateInterface*);
            StateInterface* si = dynamic_cast<StateInterface*>(newState);

            if (si == currentState)
                throw wns::Exception("replaceState(...) called with current state.");

            if (currentState)
            {
                MESSAGE_BEGIN(NORMAL, logger, m, "State replacement: ");
                m << wns::TypeInfo::create(*currentState)
                  << " -> "
                  << wns::TypeInfo::create(*si);
                MESSAGE_END();

                delete currentState;
            }

            stateCreated = false;

            currentState = si;
            currentState->initState();
        }

    protected:
        StateInterface*
        getState() const
        {
            assure(currentState, "FSM not initialized. Please set state berfore sending signals.");
            return currentState;
        }

        void
        changeState(SIGNALS* newState)
        {
            assureType(newState, StateInterface*);
            StateInterface* si = dynamic_cast<StateInterface*>(newState);

            if (si == currentState)
                return;

            if (currentState)
            {
                currentState->exitState();

                MESSAGE_BEGIN(NORMAL, logger, m, "State transition: ");
                m << wns::TypeInfo::create(*currentState)
                  << " -> "
                  << wns::TypeInfo::create(*si);
                MESSAGE_END();

                delete currentState;
            }

            stateCreated = false;

            currentState = si;
            currentState->initState();
        }

    private:
        StateInterface* currentState;

        VariablesType variables;

        logger::Logger logger;

        bool stateCreated;

    }; // FSM

} // fsm
} // wns

#endif // WNS_FSM_FSM_HPP

---