acl_message.h

Go to the documentation of this file.

#ifndef FIPA_ACL_ACLMESSAGE_H
#define FIPA_ACL_ACLMESSAGE_H

#include <vector>
#include <map>
#include <string>
#include <fipa_acl/message_generator/agent_id.h>
#include <fipa_acl/message_generator/userdef_param.h>
#include <base/Time.hpp>

namespace fipa {

namespace acl {

   typedef std::string ConversationID;
   typedef std::string Protocol; 
   typedef std::string ContentLanguage;

   const extern std::string illegalWordChars;

   const extern std::string illegalWordStart;
    
class ACLMessage {

    friend class MessageFormat;

public:
    enum Performative { ACCEPT_PROPOSAL = 0, AGREE, CANCEL, CALL_FOR_PROPOSAL, CONFIRM, DISCONFIRM, FAILURE, INFORM,
                INFORM_IF, INFORM_REF, NOT_UNDERSTOOD, PROPAGATE, PROPOSE, PROXY, QUERY_IF, QUERY_REF, REFUSE,
                REJECT_PROPOSAL, REQUEST, REQUEST_WHEN, REQUEST_WHENEVER, SUBSCRIBE, END_PERFORMATIVE
              };

private:
    std::string mPerformative;
    AgentID mSender;
    std::vector<AgentID> mReceivers;
    std::vector<AgentID> mReplyTo;
    std::string mLanguage;
    std::string mEncoding;
    std::string mOntology;
    std::string mProtocol;
    std::string mConversationId;
    std::string mReplyWith;
    std::string mInReplyTo;
    base::Time mReplyBy;
    std::vector<UserdefParam> mParameters;
    std::string mContent;

public:  

    ACLMessage();
    
    ACLMessage(Performative performative);

    ACLMessage(const std::string& perf);

    bool operator==(const ACLMessage& other) const;

    void setPerformative(Performative perf);

    void setPerformative(const std::string& str);

    std::string getPerformative() const { return mPerformative; }

    Performative getPerformativeAsEnum() const { return performativeFromString(mPerformative); }

    void addReceiver(const AgentID& aid);

    void deleteReceiver(const AgentID& aid);

    void clearReceivers();

    AgentIDList getAllReceivers() const { return mReceivers; }

    void setAllReceivers(const AgentIDList& receivers) { mReceivers = receivers; }

    void addReplyTo(const AgentID& aid);
    
    void deleteReplyTo(const AgentID& aid);

    void clearReplyTo();
    
    AgentIDList getAllReplyTo() const { return mReplyTo; }

    void setAllReplyTo(const AgentIDList& replyTo) { mReplyTo = replyTo; }

    void setInReplyTo(const std::string& str) { mInReplyTo = str; }

    std::string getInReplyTo() const { return mInReplyTo; }

    void setReplyWith(const std::string& str) { mReplyWith = str; }

    std::string getReplyWith() const { return mReplyWith; }

    void setConversationID(const std::string& str) { mConversationId = str; }

    std::string getConversationID() const { return mConversationId; }

    void setProtocol(const std::string& str);

    std::string getProtocol() const { return mProtocol; }

    void setOntology(const std::string& str) { mOntology = str; }

    std::string getOntology() const { return mOntology; }

    void setEncoding(const std::string& str) { mEncoding = str; }

    std::string getEncoding() const { return mEncoding; }

    void setLanguage(const std::string& str) { mLanguage = str; }

    std::string getLanguage() const { return mLanguage; }

    void setContent(const std::string& content) { mContent = content; }

    void setBinaryContent(const std::vector<uint8_t>& content) { mContent.assign(content.begin(), content.end()); }
   
    bool hasBinaryContent() const;

    std::string getContent() const { return mContent; }

    const std::string* getContentPtr() const { return &mContent; }

    void setSender(const AgentID& sender) { mSender = sender; }

    AgentID getSender() const { return mSender; }

    void addUserdefParam(const UserdefParam& p);

    std::vector<UserdefParam> getUserdefParams() const { return mParameters;  }

    void setUserdefParams(const std::vector<UserdefParam>& p);

    base::Time getReplyBy() const { return mReplyBy; }

    void setReplyBy(const base::Time& time) { mReplyBy = time; }

    static Performative performativeFromString(const std::string& performative);

    std::string toString() const;

};

extern std::map<ACLMessage::Performative, std::string> PerformativeTxt;

}//end of acl namespace

}// end of fipa namespace
#endif