statemachine.h

Go to the documentation of this file.

#ifndef _FIPAACL_CONVMONITOR_STATEMACHINE_H_
#define _FIPAACL_CONVMONITOR_STATEMACHINE_H_

#include <fipa_acl/bitefficient_message.h>
#include <fipa_acl/conversation_monitor/state.h>
#include <fipa_acl/conversation_monitor/message_archive.h>
#include <vector>

namespace fipa {
namespace acl {

class MessageArchive;

class StateMachine
{
    friend class StateMachineReader; 

    // Initial state of the state machine, i.e. equals current state when starting 
    // the state machine
    StateId mInitialStateId;

    // Current state of the statemachine
    StateId mCurrentStateId;

    std::map<StateId, State> mStates;

    RoleMapping mRoleMapping;

    MessageArchive mMessageArchive;
    
    fipa::acl::Protocol mProtocol;

    void generateDefaultStates();

    void generateDefaultTransitions();

protected:
    void validate() const;

    void reset();

    void setInitialState(const StateId& stateId) { mInitialStateId = stateId; }

    void addState(const State& state);

    void updateRoles();

    void updateRoleMapping(const ACLMessage& msg, const Transition& transition);

public:
    std::map<StateId, State> getStates() const { return mStates; }
    
    const RoleMapping& getRoleMapping() const { return mRoleMapping; }
    
    const State& getCurrentState() const;
    
    State& getCurrentStateModifiably();

    void setCurrentStateId(const StateId& stateId) { mCurrentStateId = stateId; }

    StateId getCurrentStateId() const { return mCurrentStateId; }

    StateId getInitialStateId() const { return mInitialStateId; }
    
    void setProtocol(const fipa::acl::Protocol& protocol) { mProtocol = protocol; }

    fipa::acl::Protocol getProtocol() const { return mProtocol; }

    void setSelf(const AgentID& self);

    void consumeMessage(const ACLMessage& msg);
    
    void consumeSubStateMachineMessage(const ACLMessage& msg, const fipa::acl::StateMachine& stateMachine, int numberOfSubConversations);

    bool inFinalState() const;

    bool inFailureState() const; 

    bool cancelled() const;

    std::string toString() const;

    std::string toXML() const;
};

struct EmbeddedStateMachine
{
    // The initiator of the sub-protocol(s)
    std::string from;
    //  and it's role.
    Role fromRole;
    // The name of teh sub-protocol
    std::string name;
    // To whom responses are forwarded back. Can be empty for propagate instead of proxy.
    std::string proxiedTo;
    // and it's role.
    Role proxiedToRole;
    
    // The following attributes is mutable, as modified after the initial instantiation.
    // The conversation sets this to the actually used protocol, and the number of planned subconverstions.
    // This enables all getter methods to still be const.
    // XXX This is not the cleanest design solution!
    
    // This is set during runtime and refers to the actually used protocol. If name is a regular expression, this can be different.
    mutable std::string actualProtocol;
    
    // The planned number of sub conversations
    // -1 is the default value, which is not valid.
    int numberOfSubConversations;
    
    // If this is true, a proxied reply has been received and the embedded state machine is finished.
    bool receivedProxiedReply;
    
    /* This state machine is constructed by statemachine_reader. It then has to be copied for each actually
     * sub conversation started.
     */    
    StateMachine stateMachine;

    EmbeddedStateMachine()
        : numberOfSubConversations(-1)
    {}
    
    std::string toString() const;

    std::string toXML() const;
};

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

#endif