Transport.hpp

Go to the documentation of this file.

#ifndef FIPA_SERVICES_TRANSPORTS_TRANSPORT_HPP
#define FIPA_SERVICES_TRANSPORTS_TRANSPORT_HPP

#include <map>
#include <fipa_acl/fipa_acl.h>
#include <fipa_services/DistributedServiceDirectory.hpp>
#include <fipa_services/ServiceLocator.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <fipa_services/transports/udt/OutgoingConnection.hpp>

#include "Configuration.hpp"

namespace fipa {
namespace services {
namespace transports {

typedef boost::function1<void, const std::string&> TransportObserver;

class Transport
{
public:
    enum Type { UNKNOWN = 0x00, UDT = 0x01, TCP = 0x02, ALL = 0xFF };

    static std::map<Type, std::string> TypeTxt;

private:
    Type mType; 
    std::vector<TransportObserver> mObservers;

    Transport() {}

protected:
    Transport(Type type);

    Transport(const Configuration& configuration);

public:
    virtual ~Transport() {}

    typedef boost::shared_ptr<Transport> Ptr;

    static Transport::Ptr create(Type type);

    static Type getTypeFromTxt(const std::string& typeTxt);

    void registerObserver(TransportObserver observer);

    Type getType() const { return mType; }

    std::string getName() const { return Transport::TypeTxt[mType]; }

    static std::string getLocalIPv4Address(const std::string& interfaceName = "eth0");

    void send(const std::string& receiverName, const Address& address, const std::string& data);

    std::set<Address> getAddresses() const;

    virtual Address getAddress(const std::string& interface = "eth0") const { throw std::runtime_error("fipa::services::Transport::getAddress not implemented by transport: " + getName()); }

    virtual OutgoingConnection::Ptr establishOutgoingConnection(const Address& address) { throw std::runtime_error("fipa::services::Transport::establishOutgoingConnection not implemented by transport: " + getName()); }

    virtual void start() { throw std::runtime_error("fipa::services::Transport::start not implemented by transport: " + getName()); }

    virtual void update(bool readAllMessages = true) { throw std::runtime_error("fipa::services::transports::Transport::update not implemented by transport: " + getName()); }

    OutgoingConnection::Ptr getCachedOutgoingConnection(const std::string& receiverName, const Address& address);

    void cleanup(const std::string& receiver);

    void notify(const std::string& message);

    void setConfiguration(const Configuration& configuration) { mConfiguration = configuration; }

    const Configuration& getConfiguration() const { return mConfiguration; }

protected:
    Configuration mConfiguration;

private:
    std::map<std::string, OutgoingConnection::Ptr> mOutgoingConnections;
};

} // end namespace transports
} // end namespace services
} // end namespace fipa
#endif // FIPA_SERVICES_TRANSPORTS_TRANSPORT_HPP