state.h

Go to the documentation of this file.

#ifndef _FIPAACL_CONVMONITOR_STATE_H_
#define _FIPAACL_CONVMONITOR_STATE_H_

#include <map>
#include <vector>

#include <fipa_acl/message_generator/acl_message.h>
#include <fipa_acl/conversation_monitor/role.h>

namespace fipa {
namespace acl {

struct EmbeddedStateMachine;
class StateMachine;
class MessageArchive;
class Transition;
namespace default_transition {
    class NotUnderstood;
    class ConversationCancelling;
    class ConversationCancelSuccess;
    class ConversationCancelFailure;
    class GeneralFailure;
}

typedef std::string StateId; 
    
class State 
{
    friend class Transition;
    friend class default_transition::NotUnderstood;
    friend class default_transition::ConversationCancelling;
    friend class default_transition::ConversationCancelSuccess;
    friend class default_transition::ConversationCancelFailure;
    friend class default_transition::GeneralFailure;
    friend class StateMachineReader;
    friend class StateMachine;

private:
    StateId mId;

    bool mIsFinal;
    
    std::vector<Transition> mTransitions;

    std::vector<EmbeddedStateMachine> mEmbeddedStateMachines;
    
    std::vector<fipa::acl::StateMachine> mSubStateMachines;
    
    std::vector<Transition> mSubstateMachineProxiedTransitions;

    static std::vector<StateId> msDefaultStates;

protected:
    void setFinal(bool final) { mIsFinal = final; }

public:
    const static StateId UNDEFINED_ID;
    const static StateId NOT_UNDERSTOOD;
    const static StateId CONVERSATION_CANCELLING;
    const static StateId CONVERSATION_CANCEL_SUCCESS;
    const static StateId CONVERSATION_CANCEL_FAILURE;
    const static StateId GENERAL_FAILURE_STATE;

    State();

    State(const StateId& id);

    Transition addTransition(const Transition& t);
   
    const Transition& getTransition(const ACLMessage &msg, const MessageArchive& archive, const RoleMapping& roleMapping) const;
    
    void consumeSubStateMachineMessage(const ACLMessage& msg, const fipa::acl::StateMachine& stateMachine, const fipa::acl::RoleMapping& roleMapping, int numberOfSubConversations);
    
    const Transition& getSubstateMachineProxiedTransition(const ACLMessage &msg, const MessageArchive& archive, const RoleMapping& roleMapping);

    void generateDefaultTransitions();

    bool isFinal() const { return mIsFinal; }
    
    bool isFinished() const;

    bool isDefaultState() const;
    
    void setId(const StateId& id) { mId = id; }
    
    std::string getId() const { return mId; }

    const std::vector<Transition>& getTransitions() const { return mTransitions; }

    const std::vector<EmbeddedStateMachine>& getEmbeddedStatemachines() const { return mEmbeddedStateMachines; }
    
    void addEmbeddedStateMachine(fipa::acl::EmbeddedStateMachine embeddedStateMachine);

    std::string toString() const;

    std::string toXML() const;

};

class FinalState : public State
{
public:
    FinalState(const StateId& id);
};

class UndefinedState : public State
{
public:
    UndefinedState();
};

namespace default_state
{
    class NotUnderstood : public FinalState
    {
    public:
        NotUnderstood() : FinalState(State::NOT_UNDERSTOOD)
        {}
    };

    class ConversationCancelling : public State
    {
    public: 
        ConversationCancelling();
    };

    class ConversationCancelSuccess : public FinalState
    {
    public: 
        ConversationCancelSuccess() : FinalState(State::CONVERSATION_CANCEL_SUCCESS)
        {}
    };

    class ConversationCancelFailure : public FinalState
    {
    public: 
        ConversationCancelFailure() : FinalState(State::CONVERSATION_CANCEL_FAILURE)
        {}
    };

    class GeneralFailure : public FinalState
    {
    public: 
        GeneralFailure() : FinalState(State::GENERAL_FAILURE_STATE)
        {}
    };
}

} // end of acl
} // end of fipa

#endif