Network.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_comm_Network_hpp
#define anna_comm_Network_hpp

#include <netinet/in.h>

#include <vector>

#include <anna/core/Singleton.hpp>

#include <anna/comm/INetAddress.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace comm {

class Host;
class Device;
class Server;
class TransportFactory;
class ReceiverFactory;

class Network : public Singleton <Network> {
public:
  struct Port { enum _v { Unique, Multiple }; };
  struct DoConnect { enum _v { Yes, No }; };


  typedef std::vector <Host*> host_container; 
  typedef host_container::iterator host_iterator; 
  typedef host_container::const_iterator const_host_iterator; 
  typedef std::vector <Device*> device_container; 
  typedef device_container::iterator device_iterator; 
  typedef device_container::const_iterator const_device_iterator; 
  Device* find(const in_addr_t& address) ;

  const_device_iterator device_begin() const { return a_devices.begin(); }

  const_device_iterator device_end() const { return a_devices.end(); }

  static const Device* device(const_device_iterator ii) { return *ii; }

  device_iterator device_begin() { return a_devices.begin(); }

  device_iterator device_end() { return a_devices.end(); }

  static Device* device(device_iterator ii) { return *ii; }

  Host* find_host(const char* name) ;

  Host* find_host(const std::string& name) { return find_host(name.c_str()); }

  Host* resolve(const char* hostname) noexcept(false);

  Host* resolve(const std::string& hostname) noexcept(false) { return resolve(hostname.c_str()); }

  const_host_iterator host_begin() const { return a_hosts.begin(); }

  const_host_iterator host_end() const { return a_hosts.end(); }

  static const Host* host(const_host_iterator ii) { return *ii; }

  host_iterator host_begin() { return a_hosts.begin(); }

  host_iterator host_end() { return a_hosts.end(); }

  static Host* host(host_iterator ii) { return *ii; }

  Server* createServer(const char* ip, const int remotePort, const bool autoRecovery, TransportFactory* transportFactory = NULL, const Port::_v mode = Port::Multiple, const DoConnect::_v doConnect = DoConnect::Yes)
  noexcept(false);

  Server* createServer(const char* ip, const int remotePort, const bool autoRecovery, ReceiverFactory& receiverFactory, TransportFactory* transportFactory = NULL, const Port::_v mode = Port::Multiple, const DoConnect::_v doConnect = DoConnect::Yes)
  noexcept(false);

//   /**
//      Devuelve la instancia del anna::comm::Server asociado a la IP y puerto recibidos.
//
//      \param ip Direccion IP en la que escucha el proceso con el que queremos conectar.
//      \param remotePort Puerto remoto en el que atiendo peticiones el proceso con el que conectar.
//
//      \return La instancia de comm::Server asociado al IP y puerto recibido.
//      \warning El anna::comm::Server devuelto puede ser NULL.
//   */
//   Server* findServer (const char* ip, const int remotePort) noexcept(false);

  Server* resolveServer(const char* hostname, const int remotePort, const bool autoRecovery, TransportFactory* transportFactory = NULL, const Port::_v mode = Port::Multiple, const DoConnect::_v doConnect = DoConnect::Yes)
  noexcept(false);

  Server* resolveServer(const char* hostname, const int remotePort, const bool autoRecovery, ReceiverFactory& receiverFactory, TransportFactory* transportFactory = NULL, const Port::_v mode = Port::Multiple, const DoConnect::_v doConnect = DoConnect::Yes)
  noexcept(false);


  INetAddress getINetAddress(const char* ip, const int port) noexcept(false);

  INetAddress getINetAddress(const std::string& ip, const int port) noexcept(false);


  xml::Node* asXML(xml::Node* parent) const ;

private:
  host_container a_hosts;
  device_container a_devices;
  Host* a_cacheHost;
  Device* a_cacheDevice;

  Network() : a_cacheHost(NULL), a_cacheDevice(NULL) {;}
  Network(const Network&);

  friend class Singleton<Network>;
};

}
}

#endif