fipa::acl::BitefficientMessageFormat Class Reference

#include <bitefficient_message_format.h>

Inherits fipa::acl::MessageFormat.

Public Member Functions
virtual	~BitefficientMessageFormat ()
std::string	apply (const ACLMessage &msg) const
std::string	getBitAID (const AgentID &aid, int depth) const
	encodes an AgentID instance More...
std::string	getBitHeader () const
	puts the header toghether More...
char	getBitMessageID () const
	depending on the flags it sets the ID More...
char	getBitMessageVersion () const
	gets the message version in one byte the message version has a very specific format: digit+dot+digit More...
std::string	getBitMessageType (const ACLMessage &msg) const
	encodes the message performative; it compares the string of the message performative to all the predefined ones; if it is one of them it returns accordingly if not it returns the custom performative More...
std::string	getBitBinWord (const std::string &sword) const
	quite frequently used production; currently it does not have complete functionality: the code tables need to be implemented in order to use them More...
std::string	getBitMessageParameters (const ACLMessage &msg) const
	puts together all the message parameters More...
std::string	getBitPredefMessageParams (const ACLMessage &msg) const
	checks all predefined message parameters whether they are set or not and it encodes them accordingly More...
std::string	getBitUserdefMessageParams (const ACLMessage &msg) const
std::string	getBitUserdefParams (const std::vector< UserdefParam > &params) const
	parses a set of user defined parameters; different from the getBitUserdefMessageParams() method in that there is more general; the former is to be called only for message parameters; difference was imposed by the specification More...
std::string	bitParseParam (const UserdefParam &) const
	parses one user defined parameter the specification does not differentiate at this level between message parameters and other kinds so this method is called by both More...
std::string	getBinURLCol (const std::vector< std::string > &) const
	currently used to encode the addresses of the AgentID instances(strings) More...
std::string	getBitResolvers (const std::vector< AgentID > &aids, int depth) const
	basically a wrapper function of the getBitAIDColl(), to add the required specific flag More...
std::string	getBitAIDColl (const std::vector< AgentID > &aids, int depth) const
	parses a set of AgentID instances the resolvers depth variable that is being passed around is not modified in this function More...
std::string	getBitBinExpression (const std::string &sword, char c) const
	implements the binary expression 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(for the binary expression) and the char parameter was added to choose between them, as no other decission maker/constraint was identified More...
std::string	getBitBinExpression (double n, char base) const
	overloaded version of the above function More...
std::string	getBitBinNumber (double n, char base) const
	parses a number according to the specification(see comment 9 of the specification) for ease it is turned into a string and passed on More...
std::string	getByteLengthEncodedString (const std::string &sword) const
std::string	getBitBinString (const std::string &sword) const
	implements the binary string production; functionality not complete as code tables are not yet implemented the second argument is an explicit option for codeTables(needed for the getBitBinExpression() ) More...
std::string	getBitDigits (const std::string &dig) const
Public Member Functions inherited from fipa::acl::MessageFormat
	MessageFormat ()
virtual	~MessageFormat ()
void	setUseCodeTables (bool x)
bool	getUseCodeTables () const
void	setUpdateCodeTables (bool x)
bool	getUpdateCodeTables () const
void	setResolverDepth (int depth)
int	getResolverDepth () const
void	setVersion (const std::string &version)
std::string	getVersion () const

Detailed Description

Definition at line 9 of file bitefficient_message_format.h.

Constructor & Destructor Documentation

~BitefficientMessageFormat()

virtual fipa::acl::BitefficientMessageFormat::~BitefficientMessageFormat ( )

inlinevirtual

Definition at line 12 of file bitefficient_message_format.h.

{}

Member Function Documentation

apply()

std::string fipa::acl::BitefficientMessageFormat::apply ( const ACLMessage &  msg ) const

virtual

Applies the format to the message

Returns

the formatted message object

Implements fipa::acl::MessageFormat.

Definition at line 25 of file bitefficient_message_format.cpp.

{
    std::string mes = getBitHeader() + getBitMessageType(msg) + getBitMessageParameters(msg);

        // Since content can be of arbitrary sicne add content here
        // to avoid copying around large content object
        const std::string* content = msg.getContentPtr();
        if (!content->empty())
        {
            uint32_t digit = content->size();   
            mes += 0x04;

            // Check if there is binary content to be set
            // add choose encoding based on the respective content size
            if(strlen(content->c_str()) != digit)
            {
                if(digit <= std::numeric_limits<uint8_t>::max())
                {
                    uint8_t dataSize = digit;
                    mes += 0x16;
                    mes.append(reinterpret_cast<const char*>(&dataSize), sizeof(uint8_t));
                    mes += *content;
                } else if (digit <= std::numeric_limits<uint16_t>::max())
                {
                    uint16_t dataSize = digit;
                    dataSize = htons(dataSize);
                    mes += 0x17;
                    mes.append(reinterpret_cast<const char*>(&dataSize),sizeof(uint16_t));
                    mes += *content;
                } else {
                    digit = htonl(digit);
                    mes += 0x19;
                    mes.append(reinterpret_cast<const char*>(&digit),sizeof(uint32_t));
                    mes += *content;
                }
            } else { // use string with null terminated (more efficient)
                char digitString[100];
                snprintf(digitString,100, "%c#%d%c",0x14,digit,'\"');
                mes += digitString;
                mes += *content;
                mes += char(0x00);
            }
        }

        mes += BitefficientFormat::getEOFCollection();
    return mes;
}

bitParseParam()

std::string fipa::acl::BitefficientMessageFormat::bitParseParam

(

const UserdefParam &

p

)

const

parses one user defined parameter the specification does not differentiate at this level between message parameters and other kinds so this method is called by both

Definition at line 244 of file bitefficient_message_format.cpp.

{
    return getBitBinWord(p.getName()) + getBitBinExpression(p.getValue(),'s');
}

getBinURLCol()

std::string fipa::acl::BitefficientMessageFormat::getBinURLCol

(

const std::vector< std::string > &

adrr

)

const

currently used to encode the addresses of the AgentID instances(strings)

Definition at line 267 of file bitefficient_message_format.cpp.

{
    std::string retstr; 
    std::vector<std::string>::const_iterator it = adrr.begin();
    for (; it != adrr.end(); ++it)
        retstr = retstr + getBitBinWord(*it);

    retstr = retstr + BitefficientFormat::getEOFCollection();
    return retstr;
}

getBitAID()

std::string fipa::acl::BitefficientMessageFormat::getBitAID	(	const AgentID &	aid,
		int	depth
	)		const

encodes an AgentID instance

as some fields are optional the method first checks for their existance it also keeps record of the res_depth

Parameters

aid	AgentID object pointer to be encoded
depth	depth of the resolver tree to be encoded

Returns

the encoded agentAID as string

Definition at line 250 of file bitefficient_message_format.cpp.

{
    if (depth > 0)
        return char(0x02) + getBitBinWord(aid.getName())+
            (( aid.getAddresses().empty() == true)? "" : (char(0x02) + getBinURLCol(aid.getAddresses()))) +
            (( aid.getResolvers().empty() == true)? "" : getBitResolvers(aid.getResolvers(),depth-1)) +
            (( aid.getUserdefParams().empty() == true)? "" : getBitUserdefParams(aid.getUserdefParams())) +
            BitefficientFormat::getEOFCollection();
             
                         
    return char(0x02) + getBitBinWord(aid.getName())+
            (( aid.getAddresses().empty() == true)? "" : (char(0x02) + getBinURLCol(aid.getAddresses()))) + 
            (( aid.getUserdefParams().empty() == true)? "" : getBitUserdefParams(aid.getUserdefParams())) +
            BitefficientFormat::getEOFCollection();
}

getBitAIDColl()

std::string fipa::acl::BitefficientMessageFormat::getBitAIDColl	(	const std::vector< AgentID > &	aids,
		int	depth
	)		const

parses a set of AgentID instances the resolvers depth variable that is being passed around is not modified in this function

Definition at line 283 of file bitefficient_message_format.cpp.

{
    std::string retstr;
    std::vector<AgentID>::const_iterator it = aids.begin();
    for (; it != aids.end(); ++it)
        retstr = retstr + getBitAID(*it, depth);
    return retstr + BitefficientFormat::getEOFCollection();
}

getBitBinExpression() [1/2]

std::string fipa::acl::BitefficientMessageFormat::getBitBinExpression	(	const std::string &	sword,
		char	c
	)		const

implements the binary expression 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(for the binary expression) and the char parameter was added to choose between them, as no other decission maker/constraint was identified

Definition at line 297 of file bitefficient_message_format.cpp.

{
    //if (!sword.compare(msg.getContent())) 
    //{
    //    return char(0xff) + getBitBinString(sword);
    //}

    if (c == 's') 
        return getBitBinString(sword);

    if (c == 'w') 
        return getBitBinWord(sword);

    throw std::runtime_error("BitefficientMessageFormat: getBitBinExpression called with wrong base character");
}

getBitBinExpression() [2/2]

std::string fipa::acl::BitefficientMessageFormat::getBitBinExpression	(	double	n,
		char	base
	)		const

overloaded version of the above function

Definition at line 313 of file bitefficient_message_format.cpp.

{
    return getBitBinNumber(n,base);
}

getBitBinNumber()

std::string fipa::acl::BitefficientMessageFormat::getBitBinNumber	(	double	n,
		char	base
	)		const

parses a number according to the specification(see comment 9 of the specification) for ease it is turned into a string and passed on

Definition at line 318 of file bitefficient_message_format.cpp.

{
    std::stringstream ss (std::stringstream::in | std::stringstream::out);
    ss << n;
    std::string test = ss.str();  

    if(base == 'h') 
        return char(0x13) + BitefficientFormat::getDigits(test);
    if(base == 'o' || base == 'd') 
        return char(0x12) + BitefficientFormat::getDigits(test);

    throw std::runtime_error("BitefficientMessageFormat: getBitBinNumber called with wrong base character");
}

getBitBinString()

std::string fipa::acl::BitefficientMessageFormat::getBitBinString

(

const std::string &

sword

)

const

implements the binary string production; functionality not complete as code tables are not yet implemented the second argument is an explicit option for codeTables(needed for the getBitBinExpression() )

Definition at line 332 of file bitefficient_message_format.cpp.

{
    if (!getUseCodeTables())
    {
        return char(0x14) + ( '\"' + sword + '\"') + char(0x00);
    }
        // char(0x15) + return getCTIndex(sword);
    throw std::runtime_error("BitefficientMessageFormat does not support codetables");

}

getBitBinWord()

std::string fipa::acl::BitefficientMessageFormat::getBitBinWord

(

const std::string &

sword

)

const

quite frequently used production; currently it does not have complete functionality: the code tables need to be implemented in order to use them

Definition at line 124 of file bitefficient_message_format.cpp.

{
    if (!getUseCodeTables())
    {
        return (char(0x10) + sword + char(0x00));
    }

    throw std::runtime_error("BitefficientMessageFormat does not support codetables");
}

getBitDigits()

std::string fipa::acl::BitefficientMessageFormat::getBitDigits

(

const std::string &

dig

)

const

Get bitefficient representation of digits

getBitHeader()

std::string fipa::acl::BitefficientMessageFormat::getBitHeader

(

)

const

puts the header toghether

Definition at line 73 of file bitefficient_message_format.cpp.

{   
    std::string retstr;
    
    char id = getBitMessageID();
    char version = getBitMessageVersion();
    
    return retstr.append(1,id).append(1,version);
}

getBitMessageID()

char fipa::acl::BitefficientMessageFormat::getBitMessageID

(

)

const

depending on the flags it sets the ID

Definition at line 83 of file bitefficient_message_format.cpp.

{   
    if (!getUseCodeTables())
    {
        return 0xfa;
    }
    if (getUpdateCodeTables())
    {
        return 0xfb;
    }
    return 0xfc;
}

getBitMessageParameters()

std::string fipa::acl::BitefficientMessageFormat::getBitMessageParameters

(

const ACLMessage &

msg

)

const

puts together all the message parameters

Definition at line 134 of file bitefficient_message_format.cpp.

{
    return (getBitPredefMessageParams(msg) + getBitUserdefMessageParams(msg));
}

getBitMessageType()

std::string fipa::acl::BitefficientMessageFormat::getBitMessageType

(

const ACLMessage &

msg

)

const

encodes the message performative; it compares the string of the message performative to all the predefined ones; if it is one of them it returns accordingly if not it returns the custom performative

Definition at line 102 of file bitefficient_message_format.cpp.

{
    std::string performative = msg.getPerformative();
    // Check if we have one of the predefined performatives
    for (int i = (int) ACLMessage::ACCEPT_PROPOSAL; i < (int) ACLMessage::END_PERFORMATIVE; ++i)
    {
        if (PerformativeTxt[(ACLMessage::Performative) i] == performative)
        {               
            char a[2]; 
            a[0] = char(i+1); 
            a[1] = '\0'; 
            return std::string(a);
        }
    }

    // actually we will have user defined performative here
    if(performative.empty())
        throw MessageGeneratorException("Performative cannot be empty");
    
    return (char(0x00) + getBitBinWord(performative));
} 

getBitMessageVersion()

char fipa::acl::BitefficientMessageFormat::getBitMessageVersion

(

)

const

gets the message version in one byte the message version has a very specific format: digit+dot+digit

Definition at line 96 of file bitefficient_message_format.cpp.

{
    std::string version = getVersion();
    return char(((int) version[0]-48)*16 + ((int)version[2]-48));
}

getBitPredefMessageParams()

std::string fipa::acl::BitefficientMessageFormat::getBitPredefMessageParams

(

const ACLMessage &

msg

)

const

checks all predefined message parameters whether they are set or not and it encodes them accordingly

Content added at higher level to minimize copies of large content objects

Definition at line 141 of file bitefficient_message_format.cpp.

{
    std::string retstr;

    // Check if entries exists for the predefined message parameters
    // sender is not always required, 
    AgentID sender = msg.getSender();
    if ( !sender.empty()) 
    {
        LOG_DEBUG("Writing sender: %s", getBitAID(sender, getResolverDepth()).c_str());
        retstr = retstr + char(0x02) + getBitAID(sender, getResolverDepth()); 
    }

    std::vector<AgentID> receivers = msg.getAllReceivers();
    if (!receivers.empty())
    {
        retstr = retstr + char(0x03) + getBitAIDColl(receivers,getResolverDepth()); 
    }


    std::string replyWith = msg.getReplyWith(); 
    if (!replyWith.empty())
        retstr = retstr + char(0x05) + getBitBinExpression(replyWith,'s'); 

    if (!msg.getReplyBy().isNull())
    {
        retstr = retstr + char(0x06) + BitefficientFormat::getBinDateTimeToken(msg.getReplyBy()); 
    }
            
    std::string inReplyTo = msg.getInReplyTo();
    if (!inReplyTo.empty())
    {
        retstr = retstr + char(0x07) + getBitBinExpression(inReplyTo,'s'); 
    }

    std::vector<AgentID> replyTo = msg.getAllReplyTo();
    if (!replyTo.empty()) 
    {
        retstr = retstr + char(0x08) + getBitAIDColl(replyTo,getResolverDepth());
    }

    std::string language = msg.getLanguage();
    if (!language.empty())
    {
        retstr = retstr + char(0x09) + getBitBinExpression(language,'s'); 
    }

    std::string encoding = msg.getEncoding();
    if (!encoding.empty())
    {
        retstr = retstr + char(0x0a) + getBitBinExpression(encoding,'s');
    }

    std::string ontology = msg.getOntology();
    if (!ontology.empty())
        retstr = retstr + char(0x0b) + getBitBinExpression(ontology,'s'); 

    std::string protocol = msg.getProtocol();
    if (!protocol.empty())
    {
        retstr = retstr + char(0x0c) + getBitBinWord(protocol);
    }

    std::string conversationID = msg.getConversationID();
    if (!conversationID.empty())
        retstr = retstr + char(0x0d) + getBitBinExpression(conversationID,'s');
    
    return retstr;
}

getBitResolvers()

std::string fipa::acl::BitefficientMessageFormat::getBitResolvers	(	const std::vector< AgentID > &	aids,
		int	depth
	)		const

basically a wrapper function of the getBitAIDColl(), to add the required specific flag

Definition at line 278 of file bitefficient_message_format.cpp.

{
    return (char(0x03) + getBitAIDColl(aids,depth));
}

getBitUserdefMessageParams()

std::string fipa::acl::BitefficientMessageFormat::getBitUserdefMessageParams

(

const ACLMessage &

msg

)

const

parses all the user defined parameters of the message if any

Definition at line 212 of file bitefficient_message_format.cpp.

{
    std::string retstr;

    std::vector<UserdefParam> s = msg.getUserdefParams();
    if( s.empty() )
    {
        return retstr;
    }

    LOG_WARN("Userdefined parameters: %d", (int) s.size());
  
    std::vector<UserdefParam>::iterator it; 
    it = s.begin();
    for (; it != s.end(); ++it)
    {
        retstr = retstr + char(0x00) + bitParseParam(*it);
    }

    return retstr;
}

getBitUserdefParams()

std::string fipa::acl::BitefficientMessageFormat::getBitUserdefParams

(

const std::vector< UserdefParam > &

params

)

const

parses a set of user defined parameters; different from the getBitUserdefMessageParams() method in that there is more general; the former is to be called only for message parameters; difference was imposed by the specification

Definition at line 234 of file bitefficient_message_format.cpp.

{
    std::string retstr;
    std::vector<UserdefParam>::const_iterator it = params.begin();
    for (; it != params.end(); ++it)
        retstr = retstr + char(0x04) + bitParseParam(*it);

    return retstr;
}

getByteLengthEncodedString()

std::string fipa::acl::BitefficientMessageFormat::getByteLengthEncodedString

(

const std::string &

sword

)

const

Retrieve the byte length encoded string for the given word

Parameters

sword

String containing the data to convert

Definition at line 292 of file bitefficient_message_format.cpp.

{
    return char(0x14) + BitefficientFormat::getByteLengthEncodedString(sword) + char(0x00);
}

---

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_message_format.h
• /build/rock-master-18.09-multiagent-fipa-acl-0.20180914/src/message_generator/format/bitefficient_message_format.cpp