ServerSocket.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_ServerSocket_hpp
#define anna_comm_ServerSocket_hpp

#include <anna/core/util/Recycler.hpp>
#include <anna/core/util/Millisecond.hpp>

#include <anna/comm/Socket.hpp>
#include <anna/comm/internal/LocalConnection.hpp>

namespace anna {

namespace comm {

class INetAddress;
class BinderSocket;

class ServerSocket : public Socket {
public:
  static const Millisecond DefaultBindDelay;

  typedef Recycler<LocalConnection>::iterator iterator;

  static const int defaultBacklog = 30;

  ServerSocket(TransportFactory* transportFactory = NULL, Domain::_v domain = Socket::Domain::Inet, Type::_v type = Socket::Type::Stream) :
    Socket(domain, type, transportFactory),
    a_backlog(defaultBacklog),
    a_sharedBind(false),
    a_binderSocket(NULL),
    a_msBindDelay(DefaultBindDelay) {}

  ServerSocket(const INetAddress& localAddress, const bool sharedBind, TransportFactory* transportFactory = NULL) :
    Socket(localAddress, Socket::Type::Stream, transportFactory),
    a_backlog(defaultBacklog),
    a_sharedBind(sharedBind),
    a_binderSocket(NULL),
    a_msBindDelay(DefaultBindDelay) {}

  virtual ~ServerSocket();

  const Millisecond &getBindDelay() { return a_msBindDelay; }

  BinderSocket* getBinderSocket() { return a_binderSocket; }

  bool isSharedBind() const { return a_sharedBind; }

  void setBacklog(const int backlog) { a_backlog = backlog; }

  void setBindDelay(const Millisecond &bindDelay) { a_msBindDelay = bindDelay; }

  virtual void prepare() noexcept(false);

  LocalConnection* accept() noexcept(false);

  void release(LocalConnection* localConnection) noexcept(false);

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

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

  virtual std::string asString() const ;

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

  virtual bool eventAcceptConnection(const ClientSocket &clientSocket) noexcept(false) { return true; }

//   /**
//       Informa sobre la rotura de una conexion que se creo a partir de un ServerSocket
//
//      @param localConnection Socket que se acepto sobre el server socket y que se ha roto.
//   */
//   virtual void eventBreakLocalConnection (LocalConnection* localConnection) noexcept(false) {;}


  static LocalConnection* localConnection(iterator& ii) { return Recycler<LocalConnection>::data(ii); }

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

protected:
  ServerSocket(const INetAddress& localAddress, const bool sharedBind, Type::_v type, TransportFactory* transportFactory = NULL) :
    Socket(localAddress, type, transportFactory),
    a_backlog(defaultBacklog),
    a_sharedBind(false),
    a_binderSocket(NULL),
    a_msBindDelay(DefaultBindDelay) {}

private:
  int a_backlog;
  Recycler <LocalConnection> a_localConnections;
  const bool a_sharedBind;
  BinderSocket* a_binderSocket;
  Millisecond a_msBindDelay;

  virtual ClientSocket* allocateClientSocket() const ;
  int do_bind(const struct sockaddr *, const int len) noexcept(false);

  friend class BinderSocket;
};

}
}


#endif