fipa::acl::StateMachineReader Class Reference

implements a XML parser that generates a state machine from a given spec. file; uses the tinyXML library More...

#include <statemachine_reader.h>

Public Member Functions
StateMachine	parseStateMachineNode (TiXmlElement *statemachineElement)
State	parseStateNode (TiXmlElement *stateElement)
	method that parses the <state> element of the spec. file More...
Transition	parseTransitionNode (TiXmlElement *transitionElement)
	method that parses <transition> element of the spec. file More...
StateMachine	loadSpecification (const std::string &file)

Static Public Attributes
static const std::string	transition = std::string("transition")
static const std::string	from = std::string("from")
static const std::string	to = std::string("to")
static const std::string	target = std::string("target")
static const std::string	id = std::string("id")
static const std::string	final = std::string("final")
static const std::string	performative = std::string("performative")
static const std::string	initial = std::string("initial")
static const std::string	subprotocol = std::string("subprotocol")
static const std::string	mapping = std::string("mapping")
static const std::string	name = std::string("name")
static const std::string	proxiedTo = std::string("proxied_to")

Detailed Description

implements a XML parser that generates a state machine from a given spec. file; uses the tinyXML library

Definition at line 24 of file statemachine_reader.h.

Member Function Documentation

StateMachine fipa::acl::StateMachineReader::loadSpecification

(

const std::string &

file

)

Load the specification and return the corresponding state machine for it

Parameters

file	name of the file containing the specification for the statemachine

Returns

the statemachine build from spec

Definition at line 30 of file statemachine_reader.cpp.

{
    {
        FILE* file = fopen(protocolSpec.c_str(), "r");
        if(file)
        {
            fclose(file);
        } else {
            LOG_ERROR_S << "error loading the spec file: '" << protocolSpec << "'. File does not exist.";
            throw std::runtime_error("Error loading the specification file: '" + protocolSpec + "' -- file does not exist");
        }
    }

    TiXmlDocument file = TiXmlDocument(protocolSpec.c_str());
    
    if (!file.LoadFile())
    {
        LOG_ERROR_S << "error loading the spec file: '" << protocolSpec << "'. Please use setProtocolResourceDir(const std::string&) instead to specify the location of your protocol files";
        throw std::runtime_error("Error loading the specification file: '" + protocolSpec + "' -- tinyxml failed to load the file");
    }

    LOG_DEBUG_S << "loadSpecification: specification file 'protocolSpec'";
    TiXmlElement* statemachineElement = file.RootElement();

    StateMachine statemachine = parseStateMachineNode(statemachineElement);
    // set protocol
    boost::filesystem::path path(protocolSpec);
    statemachine.setProtocol( path.filename().string());
    
    statemachine.generateDefaultTransitions();
    statemachine.generateDefaultStates();
    statemachine.updateRoles();
    statemachine.validate();
    statemachine.reset();
    return statemachine;
}

StateMachine fipa::acl::StateMachineReader::parseStateMachineNode

(

TiXmlElement *

statemachineElement

)

Read the xml structure defining a statemachine

Parameters

statemachineElement	the element describing the stateMachine
protocolSpec	name of the file containing the specification for the statemachine

Returns

the parsed state machine

Definition at line 67 of file statemachine_reader.cpp.

{
    StateMachine statemachine;

    const char *initialState;
    
    initialState = statemachineElement->Attribute(StateMachineReader::initial.c_str());
    if (initialState)
    {
        statemachine.setInitialState(std::string(initialState));
    } else {
        throw std::runtime_error("Attribute of initial could not be retrieved");
    }
    LOG_DEBUG_S << "parseStateMachineNode: retrieved value of the \"initial\" state: " << std::string(initialState);
        
    TiXmlHandle handleSm = TiXmlHandle(statemachineElement);
    TiXmlElement* stateElement = handleSm.FirstChild( "state" ).ToElement();
    if (stateElement)
    {
        LOG_DEBUG_S << "parseStateMachineNode: found first state element";
    } else {
        LOG_WARN_S << "parseStateMachineNode: no state element found";
    }
   
    // read states nodes 
    for (; stateElement != NULL; stateElement = stateElement->NextSiblingElement("state") )
    {
        State state = parseStateNode(stateElement);
        LOG_DEBUG_S << "Adding state: " << state.toString();
        statemachine.addState(state);
    }

    return statemachine;
}

State fipa::acl::StateMachineReader::parseStateNode

(

TiXmlElement *

stateElement

)

method that parses the <state> element of the spec. file

Parameters

stateElement

Returns

the parsed state

Definition at line 102 of file statemachine_reader.cpp.

{
    State state;

    const char *stateId;
    stateId = stateElement->Attribute(StateMachineReader::id.c_str());
    if (stateId)
    {
        state.setId(std::string(stateId));
    } else {
        char buffer[512];
        sprintf(buffer, "Attribute could not be retrieved %s", StateMachineReader::id.c_str());
        throw std::runtime_error(std::string(buffer));
    }
    
    const char* final = NULL;
    final = stateElement->Attribute(StateMachineReader::final.c_str());
    if (final)
    {
        std::string isFinal(final);
        if (isFinal == "yes" || isFinal == "true" || isFinal == "1")
        {
      state.setFinal(true);
        } else if (isFinal == "no" || isFinal == "false" || isFinal == "0")
        {
        state.setFinal(false);
    } else {
            char buffer[512];
            sprintf(buffer, "Invalid value for attribute \"final\" of state node: %s", final);
        throw std::runtime_error(std::string(buffer));
        }
    }

    // Read transitions
    TiXmlHandle handleState = TiXmlHandle(stateElement);
    TiXmlElement *transitionElement = handleState.FirstChildElement(StateMachineReader::transition).ToElement();
    for (; transitionElement != NULL; transitionElement = transitionElement->NextSiblingElement(StateMachineReader::transition) )
    {
        Transition t = parseTransitionNode(transitionElement);
        state.addTransition(t);

        LOG_DEBUG_S << "parseStateNode: state: " << state.getId() << " -> transition added: from (Role) " << t.getSenderRole().getId()
                    << ", to (Role) " << t.getReceiverRole().getId() << ", target state: " << t.getTargetStateId() << ", performative "
                    << t.getPerformativeRegExp();
    }
    
    // TODO allow only 1 subProtocol per state? Throw otherwise.
    // Also adapt the structs, etc.
    
    // Read subprotocols
    TiXmlElement *subProtocolElement = handleState.FirstChildElement(StateMachineReader::subprotocol).ToElement();
    for (; subProtocolElement != NULL; subProtocolElement = subProtocolElement->NextSiblingElement(StateMachineReader::subprotocol) )
    {
        EmbeddedStateMachine esm;
        
        const std::string* name = subProtocolElement->Attribute(StateMachineReader::name);
        if (name != NULL)
        {
            esm.name = *name;
        } else {
            throw new std::runtime_error("StateMachineReader::parseStateNode subprotocol is missing 'name' attribute");
        }
        
        const std::string* from = subProtocolElement->Attribute(StateMachineReader::from);
        if (from != NULL)
        {
            esm.from = *from;
            esm.fromRole = Role( std::string(from->c_str()));
        } else {
            throw new std::runtime_error("StateMachineReader::parseStateNode mapping is missing 'from' attribute");
        }
        
        const std::string* proxiedTo = subProtocolElement->Attribute(StateMachineReader::proxiedTo);
        if (proxiedTo != NULL)
        {
            esm.proxiedTo = *proxiedTo;
            esm.proxiedToRole = Role( std::string(proxiedTo->c_str()));
        }
        
        state.addEmbeddedStateMachine(esm);
        LOG_DEBUG_S << "parseStateNode: state: " << state.getId() << " -> subprotocol added:\n" << esm.toString();
    }
    
    return state;
}

Transition fipa::acl::StateMachineReader::parseTransitionNode

(

TiXmlElement *

transitionElement

)

method that parses <transition> element of the spec. file

Parameters

transitionElement

Returns

transition

Definition at line 188 of file statemachine_reader.cpp.

{
    Transition transition;
    const char *from = NULL;
    from = transitionElement->Attribute(StateMachineReader::from.c_str());
    if ( from )
    {
        transition.setSenderRole( Role( std::string(from) ));
    } else {
        throw new std::runtime_error("StateMachineReader::parseTransitionsNode Transitions is missing 'from' attribute");
    }
        
    const char* to = NULL;
    to = transitionElement->Attribute(StateMachineReader::to.c_str());
    if (to)
    {
        transition.setReceiverRole( Role( std::string(to) ) );
    } else {
        throw new std::runtime_error("StateMachineReader::parseTransitionsNode transition is missing 'to' attribute");
    }
    
    const char* targetState = NULL;
    targetState = transitionElement->Attribute(StateMachineReader::target.c_str());
    if (targetState)
    {
    transition.setTargetState(std::string(targetState));
    } else {
        LOG_ERROR_S << "Could not retrieve attribute for target state: " << StateMachineReader::target;
        throw std::runtime_error("Could not retrieve attribute for target state");
    }

    const char* performative = NULL;
    performative = transitionElement->Attribute(StateMachineReader::performative.c_str());
    if (performative)
    {
        transition.setPerformativeRegExp( performative );
    } else {
        throw new std::runtime_error("StateMachineReader::parseTransitionsNode transition is missing 'performative' attribute");
    }
    
    return transition;
}

Member Data Documentation

const std::string fipa::acl::StateMachineReader::final = std::string("final")

static

Definition at line 33 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::from = std::string("from")

static

Definition at line 29 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::id = std::string("id")

static

Definition at line 32 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::initial = std::string("initial")

static

Definition at line 35 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::mapping = std::string("mapping")

static

Definition at line 37 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::name = std::string("name")

static

Definition at line 38 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::performative = std::string("performative")

static

Definition at line 34 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::proxiedTo = std::string("proxied_to")

static

Definition at line 39 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::subprotocol = std::string("subprotocol")

static

Definition at line 36 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::target = std::string("target")

static

Definition at line 31 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::to = std::string("to")

static

Definition at line 30 of file statemachine_reader.h.

const std::string fipa::acl::StateMachineReader::transition = std::string("transition")

static

Definition at line 28 of file statemachine_reader.h.

---

The documentation for this class was generated from the following files:

• /build/rock-master-18.09-multiagent-fipa-acl-0.20180914/src/conversation_monitor/statemachine_reader.h
• /build/rock-master-18.09-multiagent-fipa-acl-0.20180914/src/conversation_monitor/statemachine_reader.cpp