fipa::acl::BitefficientFormat Class Reference

#include <bitefficient_format.h>

Static Public Member Functions
static char	getEOFCollection ()
	returns the very used end-of-collection marker More...
static char	getEOFEnvelope ()
static std::string	getByteLengthEncodedString (const std::string &sword)
static std::string	getNullTerminatedString (const std::string &sword)
static std::string	getString (const std::string &sword)
static std::string	getCodedNumber (const std::string &cn)
	implements a coded number passed as a string it goes through it digit by digit(char by char) More...
static std::string	getCodedNaturalNumber (const std::string &cn)
	Allow proper generation of natural numbers, will remove any leading zeros. More...
static std::string	getBinDateTimeToken (const std::string &date1)
	implements the date time token production of the grammar; not complete(w.r.t. the specification) in functionality implementing the messages without the rest of the architecture makes it difficult to anticipate when and how some productions may/will be used so only a few of the productions were implemented and the char parameter was added to choose between them, as no other decission maker/constraint was identified More...
static std::string	getBinDateTimeToken (const base::Time &time)
	implements the date time token production of the grammar; not complete(w.r.t. the specification) in functionality implementing the messages without the rest of the architecture makes it difficult to anticipate when and how some productions may/will be used so only a few of the productions were implemented and the char parameter was added to choose between them, as no other decission maker/constraint was identified More...
static std::string	getBinDate (const base::Time &time)
static std::string	getBinDate (const std::string &date1)
	takes the string representing the date and passes it's digits 2 by 2(as length 2 sugstrings) to the byte encoding function it did not explicitly specify but it was induced from the way it was stated that the date is to be encoded as a coded number(comment 9 of the specification) More...
static std::string	getBinNumber (uint32_t number, bool asHex=false)
static std::string	getACLRepresentation (const representation::Type &type)
static std::string	getDigits (const std::string &numberString)
static std::string	getDigits (uint32_t number)
static std::string	getReceivedObject (const ReceivedObject &object)
static std::string	getAgentID (const AgentID &agentId)
static std::string	getAgentIDSequence (const std::vector< AgentID > &agentIds)
static std::string	getBinStringNoCodetable (const std::string &sword)

Detailed Description

Definition at line 13 of file bitefficient_format.h.

Member Function Documentation

getACLRepresentation()

std::string fipa::acl::BitefficientFormat::getACLRepresentation ( const representation::Type &  type )

static

Encode representation

Definition at line 176 of file bitefficient_format.cpp.

{
    std::string msg = "";
    switch(type)
    {
        case representation::BITEFFICIENT: 
            msg += char(0x10); break;
        case representation::STRING_REP:
            msg += char(0x11); break;
        case representation::XML:
            msg += char(0x12); break;
        default:
            throw std::runtime_error("BitefficientFormat: Cannot encode unknown acl representation");
    }

    return msg;
}

getAgentID()

std::string fipa::acl::BitefficientFormat::getAgentID ( const AgentID &  agentId )

static

Retrieve encoded agent id for envelopes

Definition at line 231 of file bitefficient_format.cpp.

{
    std::string agentIdString = char(0x02) + getNullTerminatedString(agentId.getName());
    // addresses (optional)
    {
        const Addresses& addresses = agentId.getAddresses();
        if(!addresses.empty())
        {
            Addresses::const_iterator cit = addresses.begin();
            agentIdString += char(0x02);
            for(; cit != addresses.end(); ++cit)
            {
                agentIdString +=  getNullTerminatedString(*cit);
            }
            agentIdString += getEOFCollection();
        }
    }
    // resolvers(optional)
    {
        const Resolvers& resolvers = agentId.getResolvers();
        if(!resolvers.empty())
        {
            Resolvers::const_iterator cit = resolvers.begin();
            agentIdString += char(0x03);
            for(; cit != resolvers.end(); ++cit)
            {
                agentIdString += getAgentID(*cit);
            }
            agentIdString += getEOFCollection();
        }
    }
    // userdefined parameters
    {
        const UserdefinedParameterList& userdefParams = agentId.getUserdefParams();
        if(!userdefParams.empty())
        {
            UserdefinedParameterList::const_iterator cit = userdefParams.begin();
            for(; cit != userdefParams.end(); ++cit)
            {
                agentIdString += char(0x05);
                agentIdString += getNullTerminatedString(cit->getName());
                agentIdString += getBinStringNoCodetable(cit->getValue());
            }
        }
    }
    agentIdString += getEOFCollection();
    return agentIdString;
}

getAgentIDSequence()

std::string fipa::acl::BitefficientFormat::getAgentIDSequence ( const std::vector< AgentID > &  agentIds )

static

Get sequence of agents ids

Definition at line 280 of file bitefficient_format.cpp.

{
    std::vector<AgentID>::const_iterator cit = agentIds.begin();
    std::string sequence;
    for(;cit != agentIds.end(); ++cit)
    {
        sequence += getAgentID(*cit);
    }
    sequence += getEOFCollection();
    return sequence;
}

getBinDate() [1/2]

std::string fipa::acl::BitefficientFormat::getBinDate ( const base::Time &  time )

static

Retrieve bitefficient encoding for base time

Definition at line 39 of file bitefficient_format.cpp.

{

    std::string time = baseTime.toString(base::Time::Milliseconds);

    // Input format should be "%Y%m%d-%H:%M:%S"
    // Strip ':' and '-' to allow from_iso_string to work
    boost::erase_all(time,":");
    boost::erase_all(time,"-");

    // extend millisecond field to 4 digits
    time.insert(14,sizeof(char),'0');

    return getBinDate(time);
}

getBinDate() [2/2]

std::string fipa::acl::BitefficientFormat::getBinDate ( const std::string &  date1 )

static

takes the string representing the date and passes it's digits 2 by 2(as length 2 sugstrings) to the byte encoding function it did not explicitly specify but it was induced from the way it was stated that the date is to be encoded as a coded number(comment 9 of the specification)

Definition at line 55 of file bitefficient_format.cpp.

{
    std::string retstr;
    unsigned int i;
    for (i = 0; i < date1.length(); i = i + 2)
    {
        retstr = retstr + getCodedNaturalNumber(date1.substr(i,2));
    }
    
    return retstr;
}

getBinDateTimeToken() [1/2]

std::string fipa::acl::BitefficientFormat::getBinDateTimeToken ( const std::string &  date1 )

static

implements the date time token production of the grammar; not complete(w.r.t. the specification) in functionality implementing the messages without the rest of the architecture makes it difficult to anticipate when and how some productions may/will be used so only a few of the productions were implemented and the char parameter was added to choose between them, as no other decission maker/constraint was identified

Definition at line 29 of file bitefficient_format.cpp.

{
    return char(0x20) + getBinDate(date1);
}

getBinDateTimeToken() [2/2]

std::string fipa::acl::BitefficientFormat::getBinDateTimeToken ( const base::Time &  time )

static

implements the date time token production of the grammar; not complete(w.r.t. the specification) in functionality implementing the messages without the rest of the architecture makes it difficult to anticipate when and how some productions may/will be used so only a few of the productions were implemented and the char parameter was added to choose between them, as no other decission maker/constraint was identified

Definition at line 34 of file bitefficient_format.cpp.

{
    return char(0x20) + getBinDate(time);
}

getBinNumber()

std::string fipa::acl::BitefficientFormat::getBinNumber ( uint32_t  number, bool  asHex = false  )

static

Retrieve number string

Definition at line 151 of file bitefficient_format.cpp.

{
    std::string encoded;
    if(asHex)
    {
        encoded += char(0x13);
    } else {
        encoded += char(0x12);
    }

    std::stringstream ss;
    ss << number;

    encoded += getDigits(ss.str());
    return encoded;
}

getBinStringNoCodetable()

static std::string fipa::acl::BitefficientFormat::getBinStringNoCodetable ( const std::string &  sword )

inlinestatic

Definition at line 108 of file bitefficient_format.h.

{ return char(0x14) + getNullTerminatedString(sword); }

getByteLengthEncodedString()

std::string fipa::acl::BitefficientFormat::getByteLengthEncodedString ( const std::string &  sword )

static

Definition at line 15 of file bitefficient_format.cpp.

{
    char digitString[100];
    int digit = sword.size();   
    snprintf(digitString,100, "#%d%c",digit,'\"');
    
    return digitString + sword;
}

getCodedNaturalNumber()

std::string fipa::acl::BitefficientFormat::getCodedNaturalNumber ( const std::string &  cn )

static

Allow proper generation of natural numbers, will remove any leading zeros.

Definition at line 101 of file bitefficient_format.cpp.

{
    std::string retstr;

    unsigned int i;
    char code(0x00);
    size_t decimal_size = cn.length();

    for(i = 0; i < decimal_size; ++i)
    {
        switch(cn[i])
        {
            // Ignoring leading zeros here, 
            case '0': code += char(0x01); break;
            case '1': code += char(0x02); break;
            case '2': code += char(0x03); break;
            case '3': code += char(0x04); break;
            case '4': code += char(0x05); break;
            case '5': code += char(0x06); break;
            case '6': code += char(0x07); break;
            case '7': code += char(0x08); break;
            case '8': code += char(0x09); break;
            case '9': code += char(0x0a); break;
            //case '+': code += char(0x0c); break;
            //case 'e': 
            //case 'E': code += char(0x0d); break;
            //case '-': code += char(0x0e); break;
            //case '.': code += char(0x0f); break;
            default: 
                      assert(false);
        }

          
        if (i%2 == 0)
        { 
            code = code<<4;
        } else {
            retstr += code; 
            code = char(0x00); 
        }
    }

    if (i%2 != 0)
    {
        retstr += code;
    }
     
    return retstr;
}

getCodedNumber()

std::string fipa::acl::BitefficientFormat::getCodedNumber ( const std::string &  cn )

static

implements a coded number passed as a string it goes through it digit by digit(char by char)

Definition at line 67 of file bitefficient_format.cpp.

{
    std::string retstr;
    unsigned int i;
    char code(0x00);
    size_t decimal_size = cn.length();

    for(i = 0; i < decimal_size; i++)
    {
        if ((cn[i]>='0') && (cn[i]<='9')) code = char(code + 1 + int(cn[i]) - 48);
        if (cn[i] == '+') code = char(code + 12);
        if ((cn[i] == 'E') || (cn[i] == 'e')) code = char(code + 13);
        if (cn[i] == '-') code = char(code + 14);
        if (cn[i] == '.') code = char(code + 15);
        
        if (i%2 == 0)
        {
            code = code<<4;
        } else {
            retstr += code;
            code = char(0x00);
        }
    }

    if (decimal_size % 2 != 0)
    {
        retstr += code;
    } else {
        retstr += char(0x00);
    }
     
    return retstr;
}

getDigits() [1/2]

static std::string fipa::acl::BitefficientFormat::getDigits ( const std::string &  numberString )

inlinestatic

Retrieve digits for a number string

Definition at line 83 of file bitefficient_format.h.

{ return getCodedNumber(numberString); }

getDigits() [2/2]

std::string fipa::acl::BitefficientFormat::getDigits ( uint32_t  number )

static

Get digits from unsigned integer

Definition at line 168 of file bitefficient_format.cpp.

{
    std::stringstream ss;
    ss << number;

    return getDigits(ss.str());
}

getEOFCollection()

static char fipa::acl::BitefficientFormat::getEOFCollection ( )

inlinestatic

returns the very used end-of-collection marker

Definition at line 19 of file bitefficient_format.h.

{ return 0x01; }

getEOFEnvelope()

static char fipa::acl::BitefficientFormat::getEOFEnvelope ( )

inlinestatic

Definition at line 21 of file bitefficient_format.h.

{ return getEOFCollection(); }

getNullTerminatedString()

std::string fipa::acl::BitefficientFormat::getNullTerminatedString ( const std::string &  sword )

static

Definition at line 24 of file bitefficient_format.cpp.

{
    return getByteLengthEncodedString(string) + char(0x00);
}

getReceivedObject()

std::string fipa::acl::BitefficientFormat::getReceivedObject ( const ReceivedObject &  object )

static

Retrieve encoded received object

Definition at line 194 of file bitefficient_format.cpp.

{
    // by
    std::string receivedObjectString = getNullTerminatedString(receivedObject.getBy());
    // date
    receivedObjectString += getBinDateTimeToken(receivedObject.getDate());
    // from
    std::string from = receivedObject.getFrom();
    if(!from.empty())
    {
        receivedObjectString += char(0x02) + getNullTerminatedString(from);
    }
    // id
    std::string id = receivedObject.getId();
    if(!id.empty())
    {
        receivedObjectString += char(0x03) + getNullTerminatedString(id);
    }
    // via
    std::string via = receivedObject.getVia();
    if(!via.empty())
    {
        receivedObjectString += char(0x04) + getNullTerminatedString(via);
    }
    
    const UserdefinedParameterList& list = receivedObject.getUserdefinedParameters();
    std::vector<UserdefParam>::const_iterator cit = list.begin();
    for(; cit != list.end(); ++cit)
    {
        receivedObjectString += char(0x00) + getNullTerminatedString(cit->getName()) + getNullTerminatedString(cit->getValue());
    }

    receivedObjectString += getEOFCollection();

    return receivedObjectString;
}

getString()

std::string fipa::acl::BitefficientFormat::getString ( const std::string &  sword )

static

Return encoded string

Definition at line 9 of file bitefficient_format.cpp.

{
    // StringLiteral | ByteLengthEncodedString
    return getByteLengthEncodedString(sword);
}

---

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

• /build/rock-master-18.09-multiagent-fipa-acl-0.20180914/src/message_generator/format/bitefficient_format.h
• /build/rock-master-18.09-multiagent-fipa-acl-0.20180914/src/message_generator/format/bitefficient_format.cpp