Server.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_Server_hpp
#define anna_comm_Server_hpp

#include <vector>
#include <algorithm>

#include <anna/config/defines.hpp>

#include <anna/comm/Resource.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace comm {

class Host;
class TransportFactory;
class Service;
class Message;
class INetAddress;
class ClientSocket;
class ServerAllocator;
class ReceiverFactory;

class Server : public Resource {
public:
  typedef std::vector <Service*> Services;
  typedef Services::iterator iterator;
  typedef Services::const_iterator const_iterator;

  virtual ~Server();

  const Host* getHost() const { return &a_host; }

  const ClientSocket* getClientSocket() const { return a_clientSocket; }

  int getRemotePort() const { return a_remotePort; }

  bool autoRecovery() const { return a_autoRecovery; }

  void setAutoRecovery(bool autoRecovery = true) ;

  bool isAvailable() const noexcept(false);

  TransportFactory* getTransportFactory() { return a_transportFactory; }

  const Millisecond &getMaxConnectionDelay() const { return a_msMaxConnectionDelay; }

  const Millisecond &getMaxWriteDelay() const { return a_msMaxWriteDelay; }

  ReceiverFactory* getReceiverFactory() { return a_receiverFactory; }

  void setMaxConnectionDelay(const Millisecond &msMaxConnectionDelay)
  {
    a_msMaxConnectionDelay = msMaxConnectionDelay;
  }

  void setMaxWriteDelay(const Millisecond &msMaxWriteDelay) { a_msMaxWriteDelay = msMaxWriteDelay; }

  void setReceiverFactory(ReceiverFactory& receiverFactory) ;

  bool getIgnoreIncomingMessages() const { return a_ignoreIncomingMessages; }

  void setIgnoreIncomingMessages(const bool ignoreIncomingMessages) { a_ignoreIncomingMessages = ignoreIncomingMessages; }

  void attach(Service* service)
  noexcept(false) {
    if(std::find(begin(), end(), service) == end())
      a_services.push_back(service);
  }

  void connect() noexcept(false);

  ClientSocket* send(Message& message) noexcept(false);

  ClientSocket* send(Message* message) noexcept(false);

  void reset() noexcept(false);

  const_iterator begin() const { return a_services.begin(); }

  const_iterator end() const { return a_services.end(); }

  iterator begin() { return a_services.begin(); }

  iterator end() { return a_services.end(); }

  std::string asString() const ;

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

  static Service* service(iterator& ii) { return *ii; }

  static const Service* service(const_iterator& ii) { return *ii; }

  static const char* className() { return "anna::comm::Server"; }

protected:
  Server(const std::string& name, const Host& host, const int remotePort, const bool autoRecovery, TransportFactory* transportFactory);

private:
  const Host& a_host;
  const int a_remotePort;
  const bool a_autoRecovery;
  Services a_services;
  TransportFactory* a_transportFactory;
  ClientSocket* a_clientSocket;
  Millisecond a_msMaxConnectionDelay;
  Millisecond a_msMaxWriteDelay;
  ReceiverFactory* a_receiverFactory;
  bool a_ignoreIncomingMessages;
  int a_sequence;

  virtual ClientSocket* allocateClientSocket(const INetAddress&, TransportFactory*) const ;

  friend class Host;
  friend class ServerAllocator;
};

}
}

#endif