fipa::acl::XMLParser Class Reference

#include <xml_parser.h>

Static Public Member Functions
static const ReceivedObject	parseReceivedObject (const TiXmlElement *receivedObjectElem)
static const base::Time	parseDate (const TiXmlElement *dateElem)
static const base::Time	strToDate (const std::string &dateStr)
static const std::string	parseURL (const TiXmlElement *urlElem)
static const std::string	parseName (const TiXmlElement *nameElem)
static const AgentID	parseAgentID (const TiXmlElement *aidElem)
static const AgentIDList	parseAgentIDSequence (const TiXmlElement *aidlElem)
static const UserdefParam	parseUserdefinedParameter (const TiXmlElement *paramElem)
static const char *	extractContentOrAttribute (const TiXmlElement *elem, const char *identifier="href")

Detailed Description

A set of static methods to parse certain XML elemenets containing FIPA compliant data. All methods throw an exception of the content is not FIPA compliant.

Definition at line 18 of file xml_parser.h.

Member Function Documentation

const char * fipa::acl::XMLParser::extractContentOrAttribute ( const TiXmlElement *  elem, const char *  identifier = "href"  )

static

For all message parameters FIPA allows to set the content directly or to point to an URL with a href attribute. The content of either will be returned or NULL if none is set.

Definition at line 219 of file xml_parser.cpp.

{
    const char* text = elem->GetText();
    if(text != NULL)
    {
        return text;
    }
    return elem->Attribute(identifier);
}

const AgentID fipa::acl::XMLParser::parseAgentID ( const TiXmlElement *  aidElem )

static

Definition at line 8 of file xml_parser.cpp.

{
    if(aidElem->ValueStr() != "agent-identifier")
    {
        throw std::runtime_error("Parsing error: node not named 'agent-identifier' but " + aidElem->ValueStr());
    }
    
    AgentID aid;
    
    const TiXmlElement * pChild = aidElem->FirstChildElement();
    // The first child is the name
    aid.setName(parseName(pChild));
    
    for ( pChild = pChild->NextSiblingElement(); pChild != 0; pChild = pChild->NextSiblingElement()) 
    {
        // The remaining childs can be resolvers, addresses, or user-defined parameters
        const std::string& text = pChild->ValueStr();
        if(text == "addresses")
        {
            // Each child element is an URL
            const TiXmlElement * pInnerChild;
            for ( pInnerChild = pChild->FirstChildElement(); pInnerChild != 0; pInnerChild = pInnerChild->NextSiblingElement()) 
            {
                aid.addAddress(parseURL(pInnerChild));
            }
        }
        else if(text == "resolvers")
        {
            // It's a list of agent ids
            aid.setResolvers(parseAgentIDSequence(pChild));
        }
        else if(text.substr(0, 2) == "X-")
        {
            aid.addUserdefParam(parseUserdefinedParameter(pChild));
        }
    }
    return aid;
}

const AgentIDList fipa::acl::XMLParser::parseAgentIDSequence ( const TiXmlElement *  aidlElem )

static

Definition at line 47 of file xml_parser.cpp.

{
    AgentIDList list;
    // All children are AgentIDs
    const TiXmlElement * pChild;
    for ( pChild = aidlElem->FirstChildElement(); pChild != 0; pChild = pChild->NextSiblingElement()) 
    {
        list.push_back(parseAgentID(pChild));
    }
    return list;
}

const base::Time fipa::acl::XMLParser::parseDate ( const TiXmlElement *  dateElem )

static

Definition at line 59 of file xml_parser.cpp.

{
    const char* date = dateElem->GetText();
    if(date == NULL)
    {
        throw std::runtime_error("ill-formed date element");
    }
    return strToDate(std::string(date));
}

const std::string fipa::acl::XMLParser::parseName ( const TiXmlElement *  nameElem )

static

Definition at line 69 of file xml_parser.cpp.

{
    if(nameElem->ValueStr() != "name")
    {
        throw std::runtime_error("Parsing error: node not named 'name' but " + nameElem->ValueStr());
    }
    
    // Name can be the value or in an "id" or "refid" attribute
    const char* p = nameElem->GetText();
    if(p != NULL)
    {
        return std::string(p);
    }
    p = nameElem->Attribute("id");
    if(p != NULL)
    {
        return std::string(p);
    }
    p = nameElem->Attribute("refid");
    if(p != NULL)
    {
        return std::string(p);
    }
    throw std::runtime_error("ill-formed name element");
}

const ReceivedObject fipa::acl::XMLParser::parseReceivedObject ( const TiXmlElement *  receivedObjectElem )

static

Definition at line 95 of file xml_parser.cpp.

{
    ReceivedObject ro;
    UserdefinedParameterList params;
    
    // Each element here can also have an "value" attribute
    
    const TiXmlElement * pChild = receivedObjectElem->FirstChildElement();
    // The first child is received-by
    const std::string* byValue = pChild->Attribute(std::string("value"));
    if(byValue != NULL)
    {
        ro.setBy(*byValue);
    }
    else
    {
        // Then it must be url child
        const std::string byUrl = parseURL(pChild->FirstChildElement());
        ro.setBy(byUrl);
    }
    
    for ( pChild = pChild->NextSiblingElement(); pChild != 0; pChild = pChild->NextSiblingElement()) 
    {
        // The remaining childs can be received-from, received-date, received-id, received-via, and user-defined
        const std::string& text = pChild->ValueStr();
        if(text == "received-from")
        {
            const std::string* fromValue = pChild->Attribute(std::string("value"));
            if(fromValue != NULL)
            {
                ro.setFrom(*fromValue);
            }
            else
            {
                // Then it must be url child
                const std::string fromUrl = parseURL(pChild->FirstChildElement());
                ro.setFrom(fromUrl);
            }
        }
        else if(text == "received-date")
        {
            const std::string* date = pChild->Attribute(std::string("value"));
            if(date == NULL)
            {
                throw std::runtime_error("ill-formed received-date element");
            }
            ro.setDate(strToDate(*date));
        }
        else if(text == "received-id")
        {
            const std::string* id = pChild->Attribute(std::string("value"));
            if(id == NULL)
            {
                throw std::runtime_error("ill-formed received-id element");
            }
            ro.setId(*id);
        }
        else if(text == "received-via")
        {
            const std::string* via = pChild->Attribute(std::string("value"));
            if(via == NULL)
            {
                throw std::runtime_error("ill-formed received-via element");
            }
            ro.setId(*via);
        }
        else if(text == "user-defined")
        {
            params.push_back(parseUserdefinedParameter(pChild));
        }
    }
    // Since there is no "addUserdefParam" in ReceivedObject
    ro.setUserdefinedParameters(params);
    
    return ro;
}

const std::string fipa::acl::XMLParser::parseURL ( const TiXmlElement *  urlElem )

static

Definition at line 172 of file xml_parser.cpp.

{
    if(urlElem->ValueStr() != "url")
    {
        throw std::runtime_error("Parsing error: node not named 'url' but " + urlElem->ValueStr());
    }
    
    // URL can be the value or in an href attribute
    const char* url = extractContentOrAttribute(urlElem);
    if(url == NULL)
    {
        throw std::runtime_error("ill-formed URL element");
    }
    return std::string(url);
}

const UserdefParam fipa::acl::XMLParser::parseUserdefinedParameter ( const TiXmlElement *  paramElem )

static

Definition at line 188 of file xml_parser.cpp.

{
    const char* href = paramElem->Attribute("href");
    const char* value = paramElem->GetText();
    // Throw an exception if either is NULL
    if(href == NULL || value == NULL)
    {
        throw std::runtime_error("ill-formed user defined parameter");
    }
    // cut "X-"
    return UserdefParam(std::string(href).substr(2), std::string(value));
    
}

const base::Time fipa::acl::XMLParser::strToDate ( const std::string &  dateStr )

static

Definition at line 202 of file xml_parser.cpp.

{
    // XXX this does not parse relative times (+/- as first char), or UTC Z at the end.
    
    // Put a colon back after seconds
    const std::string modDateStr = dateStr.substr(0, 15) + ":" + dateStr.substr(15);
    try
    {
        return base::Time::fromString(modDateStr, base::Time::Milliseconds, "%Y%m%dT%H%M%S");
    }
    catch(std::exception& e)
    {
        // Maybe JADE's "Z"?
        return base::Time::fromString(modDateStr, base::Time::Milliseconds, "%Y%m%dZ%H%M%S");
    }
}

---

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

• /build/rock-master-18.09-multiagent-fipa-acl-0.20180914/src/message_parser/xml_parser.h
• /build/rock-master-18.09-multiagent-fipa-acl-0.20180914/src/message_parser/xml_parser.cpp