MessageTransport.hpp

Go to the documentation of this file.

#ifndef FIPA_SERVICE_MESSAGE_TRANSPORT_SERVICE_HPP
#define FIPA_SERVICE_MESSAGE_TRANSPORT_SERVICE_HPP

#include <map>
#include <fipa_acl/fipa_acl.h>
#include <boost/function.hpp>
#include <stdexcept>
#include <fipa_services/transports/Transport.hpp>
#include <fipa_services/transports/Configuration.hpp>
#include <fipa_services/ServiceDirectory.hpp>

namespace fipa {
namespace agent_management {
    const std::string ONTOLOGY = "fipa-agent-management";
    const std::string INTERNAL_ERROR = "internal-error";
    const std::string INTERNAL_COMMUNICATION = "internal-communication";
}

namespace services {
namespace message_transport {

typedef boost::function2<bool, const std::string&, const fipa::acl::Letter&> MessageTransportHandler;

typedef std::map<std::string, MessageTransportHandler> MessageTransportHandlerMap;
typedef std::vector<std::string> MessageTransportPriorityList;

class MessageTransport
{
private:
    fipa::acl::AgentID mAgentId;
    ServiceDirectory::Ptr mpServiceDirectory;

    MessageTransportHandlerMap mMessageTransportHandlerMap;
    MessageTransportPriorityList mMessageTransportPriorityList;

    mutable std::map<transports::Transport::Type, transports::Transport::Ptr> mActiveTransports;
    std::vector<transports::Configuration> mTransportConfigurations;

    std::vector<fipa::services::ServiceLocation> mTransportEndpoints;

    // Representation which is used to exchange internal messages
    // default is bitefficient
    fipa::acl::representation::Type mRepresentation;

    std::string mServiceSignature;
    std::set<std::string> mAcceptedServiceSignatures;

    void stamp(fipa::acl::Letter& msg) const;

    bool hasStamp(const fipa::acl::Letter& msg) const;

    fipa::acl::ACLMessage createInternalErrorMessage(const fipa::acl::ACLMessage& msg, const std::string& description) const;

    bool localForward(const std::string& receiverName, const fipa::acl::Letter& msg) const;

    fipa::acl::AgentIDList forward(const fipa::acl::Letter& letter) const;

    void forward(const std::string& receiverName, const ServiceLocation& location, const fipa::acl::Letter& letter) const;

    bool hasActiveTransport(const std::string& protocol) const;

    bool isLocal(const ServiceLocation& local) const;

    void handleData(const std::string& data);

    static void removeFromList(const fipa::acl::AgentID& receiver, fipa::acl::AgentIDList& receiversList);

    void cacheTransportEndpoints(fipa::services::transports::Transport::Ptr transport);

public:

    MessageTransport(const fipa::acl::AgentID& id, ServiceDirectory::Ptr serviceDirectory);

    fipa::acl::AgentID getAgentID() const { return mAgentId; }

    void configure(const std::vector<transports::Configuration>& configurations) { mTransportConfigurations = configurations; }

    void activateTransports(const std::vector<std::string>& transports);

    void activateTransports(transports::Transport::Type flags);

    void activateTransport(transports::Transport::Type type);

    std::vector<fipa::services::ServiceLocation> getTransportEndpoints() const;

    void handle(fipa::acl::Letter& msg);

    void handleError(const fipa::acl::Letter& msg) const;

    void registerMessageTransport(const std::string& id, MessageTransportHandler handler);

    void deregisterMessageTransport(const std::string& id);

    void modifyMessageTransport(const std::string& id, MessageTransportHandler handler);

    bool handleInternalCommunication(const fipa::acl::Letter& letter);

    void setInternalMessageRepresentationType(const fipa::acl::representation::Type& representation) { mRepresentation = representation; }

    fipa::acl::representation::Type getInternalMessageRepresentationType() const { return mRepresentation; }

    void trigger();

    std::string getServiceSignature() const { return mServiceSignature; }

    void addAcceptedServiceSignature(const std::string& signature) { mAcceptedServiceSignatures.insert(signature); }

    ServiceDirectory::Ptr getServiceDirectory() { return mpServiceDirectory; }

    void registerClient(const std::string& clientName, const std::string& clientDescription);

    void deregisterClient(const std::string& clientName);

    std::string serializeLetter(const fipa::acl::Letter& letter, const std::string& signature) const;

};

} // end namespace message_transport
} // end namespace services
} // end namespace fipa

#endif // FIPA_SERVICE_MESSAGE_TRANSPORT_SERVICE_HPP