Host.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_Host_hpp
#define anna_comm_Host_hpp

#include <algorithm>
#include <vector>
#include <map>
#include <string>

#include <anna/core/mt/Mutex.hpp>
#include <anna/core/util/MultiMap.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace comm {

class Communicator;
class Server;
class TransportFactory;
class Device;
class Network;
class ServerAllocator;

class Host : public Mutex {

  typedef int Port;

  // Requerido por Forte C++
//   struct Comparator;
//   friend struct Comparator;


  struct SortBy {
    static int value(const Server* server) ;
  };

  std::string a_name;

public:

  typedef std::vector <const Device*> device_container;
  typedef device_container::const_iterator const_device_iterator; 
  typedef MultiMap <Server, SortBy> server_container;

  typedef server_container::iterator server_iterator; 
  typedef server_container::const_iterator const_server_iterator; 
  virtual ~Host();

  const std::string& getName() const { return a_name; }

  Server* createServer(const char* name, const int remotePort, const bool autoRecovery, TransportFactory* transportFactory = NULL, const bool ignoreIncomingMessages = false, const bool doConnect = true)
  noexcept(false) {
    return createServer(std::string(name), remotePort, autoRecovery, transportFactory, ignoreIncomingMessages, doConnect);
  }

  Server* createServer(const std::string& name, const int remotePort, const bool autoRecovery, TransportFactory* transportFactory = NULL, const bool ignoreIncomingMessages = false, const bool doConnect = true)
  noexcept(false);

  Server* createServer(const ServerAllocator& serverAllocator) noexcept(false);

  server_iterator server_begin() { return a_servers.begin(); }

  const_server_iterator server_begin() const { return a_servers.begin(); }

  server_iterator server_end() { return a_servers.end(); }

  const_server_iterator server_end() const { return a_servers.end(); }

  static Server* server(server_iterator ii) { return server_container::data(ii); }

  static const Server* server(const_server_iterator ii) { return server_container::data(ii); }


  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; }

  const Server* find_server(const int remotePort) const ;

  Server* find_server(const int remotePort) ;
  void assign(const Device* device) noexcept(false);

  bool contains(const Device* device) const
  {
    const_device_iterator end = device_end();
    return (std::find(device_begin(), end, device) != end);
  }

  std::string asString() const ;

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


protected:
  Host(const char* name) : a_name(name) {}

private:
  device_container a_devices;
  server_container a_servers;

  Server* add(Server*, const int remotePort, const bool doConnect) ;

  friend class Network;
};

}
}

#endif