*/
class Communicator : public app::Component {
struct SortByFileDescriptor {
- static int value(const Handler*) throw();
+ static int value(const Handler*) ;
};
/**
@return El numero de segundos esperado para intentar recuperar las conexiones de los servidores
con los que se han detectado errores de conexion.
*/
- const Millisecond &getRecoveryTime() const throw() { return a_recoveryTime; }
+ const Millisecond &getRecoveryTime() const { return a_recoveryTime; }
/**
Devuelve el estado de este proceso con respecto al sistema de comunicaciones.
\return El estado de este proceso con respecto al sistema de comunicaciones.
*/
- const Status& getStatus() const throw() { return a_status; }
+ const Status& getStatus() const { return a_status; }
/**
Devuelve el numero de milisegundos maximo que puede estar un manejador de conexion local
\return el numero de milisegundos maximo que puede estar un manejador de conexion local
sin recibir mensajes antes de ser cerrado por el nucleo.
*/
- const Millisecond &getTimeout() const throw() { return a_timeout; }
+ const Millisecond &getTimeout() const { return a_timeout; }
/**
* Devuelve el modo de tratamiento de conexiones establecido en el constructor.
*/
- WorkMode::_v getWorkMode() const throw() { return a_workMode; }
+ WorkMode::_v getWorkMode() const { return a_workMode; }
/**
Devuelve \em true si este comunicador esta atendiendo peticiones como servidor o \em false en otro
@return \em true si este comunicador esta atendiendo peticiones como servidor o \em false en otro
caso.
*/
- bool isServing() const throw() { return a_isServing; }
+ bool isServing() const { return a_isServing; }
/**
Devuelve el estado del indicador de peticion de parada.
\return el estado del indicador de peticion de parada.
*/
- bool hasRequestedStop() const throw() { return a_requestedStop; }
+ bool hasRequestedStop() const { return a_requestedStop; }
/**
* Informa al comunicador de que hay algún socket que ha solicitado el cierre de la conexión.
*/
- void notifyPendingClose() throw() { a_pendingClose = true; }
+ void notifyPendingClose() { a_pendingClose = true; }
/**
Establece el numero de milisegundos esperado para intentar recuperar las conexiones de los servidores
\warning el valor indicado deberá estar entre #MinRecoveryTime y #MaxRecoveryTime
*/
- void setRecoveryTime(const Millisecond &recoveryTime) throw(RuntimeException);
+ void setRecoveryTime(const Millisecond &recoveryTime) noexcept(false);
/**
Establece el numero de milisegundos empleados en intentar conectar con los servidores caídos cada
\warning el valor indicado deberá estar entre #MinTryingConnectionTime y #MaxTryingConnectionTime
*/
- void setTryingConnectionTime(const Millisecond &tryingConnectionTime) throw(RuntimeException);
+ void setTryingConnectionTime(const Millisecond &tryingConnectionTime) noexcept(false);
/**
* Devuelve el numero de milisegundos empleados en intentar conectar con los servidores caídos.
*/
- const Millisecond &getTryingConnectionTime() const throw() { return a_tryingConnectionTime; }
+ const Millisecond &getTryingConnectionTime() const { return a_tryingConnectionTime; }
/**
* Establece el tamaño del bloque de memoria usado para procesar los mensajes entrantes. Todos
* cuando se cambia este valor también se invocará a CongestionController::setMaxPendingBytes para
* establecer este mismo valor.
*/
- static void setReceivingChunkSize(const int receivingChunkSize) throw(RuntimeException);
+ static void setReceivingChunkSize(const int receivingChunkSize) noexcept(false);
/**
* Obtiene el tamaño máximo del bloque de memoria a procesar de forma ininterrumpida.
* \return el tamaño máximo del bloque de memoria a procesar de forma ininterrumpida.
*/
- static int getReceivingChunkSize() throw() { return st_ReceivingChunkSize; }
+ static int getReceivingChunkSize() { return st_ReceivingChunkSize; }
/**
Establece el numero de milisegundos maximo que puede estar un manejador de conexion local
sin recibir mensajes antes de ser cerrado por el nucleo.
\param timeout Numero de milisegundos maximo sin recibir mensajes.
*/
- void setTimeout(const Millisecond & timeout) throw() { a_timeout = timeout; }
+ void setTimeout(const Millisecond & timeout) { a_timeout = timeout; }
/**
* Establece el nivel de congestión global a partir del cual un servidor no aceptará nuevas conexiones. Su valor
*
* \warning Debe estar entre [comm::CongestionController::MaxLevel - 2, comm::CongestionController::MaxLevel].
*/
- void setLevelOfDenialService(const int levelOfDenialService) throw(RuntimeException);
+ void setLevelOfDenialService(const int levelOfDenialService) noexcept(false);
/**
* Devuelve el nivel de congestión a partir del cual un servidor no aceptará nuevas conexiones.
* \return el nivel de congestión a partir del cual un servidor no aceptará nuevas conexiones.
*/
- int getLevelOfDenialService() const throw() { return a_levelOfDenialService; }
+ int getLevelOfDenialService() const { return a_levelOfDenialService; }
/**
Registra un servidor de socket a la lista de peticiones por las que atiende peticiones este
\param serverSocket Servidor de socket por el que vamos a atender el establecimiento de conexiones
una vez que invoquemos al Metodo #accept.
*/
- void attach(ServerSocket* serverSocket) throw(RuntimeException);
+ void attach(ServerSocket* serverSocket) noexcept(false);
/**
Registra una conexion Local entre alguno de los ServerSocket definidos en nuestra aplicacion
\warning Exclusivamente uso interno
*/
- void attach(LocalConnection* localConnection) throw(RuntimeException);
+ void attach(LocalConnection* localConnection) noexcept(false);
/**
Establece la conexion entre el comunicador y un ClientSocket recibido como parametro.
\param clientSocket Instancia del socket que vamos a controlar.
*/
- void attach(ClientSocket* clientSocket) throw(RuntimeException);
+ void attach(ClientSocket* clientSocket) noexcept(false);
/**
Establece la conexion entre el comunicador y un DatagramSocket recibido como parametro.
\param datagramSocket Instancia del socket que vamos a controlar.
*/
- void attach(DatagramSocket* datagramSocket) throw(RuntimeException);
+ void attach(DatagramSocket* datagramSocket) noexcept(false);
/**
Conecta un conector externo a este comunicador.
\param handler Controlador de comunicaciones externas.
\warning Debe de haber sido creado como de tipo Handler::Type::Custom.
*/
- void attach(Handler* handler) throw(RuntimeException);
+ void attach(Handler* handler) noexcept(false);
/**
Conecta un servicio de reparto de comunicaciones con este comunicador. El estado de
\param service Instancia del servicio.
\warning Todos los servicios registrados como criticos deberian estar asociados al comunicador.
*/
- void attach(Service* service) throw(RuntimeException);
+ void attach(Service* service) noexcept(false);
/**
Desconecta el ServerSocket que fue previamente conectado con #attach
\warning Este metodo es invocado automaticamente desde el nucleo de anna.comm y no deberia
ser usado por el programador final.
*/
- void detach(ServerSocket* serverSocket) throw();
+ void detach(ServerSocket* serverSocket) ;
/**
Desconecta el ClientSocket que fue previamente conectado con #attach
\warning Este metodo es invocado automaticamente desde el nucleo de ANNA.comm y no deberia
ser usado por el programador final.
*/
- void detach(ClientSocket* clientSocket) throw();
+ void detach(ClientSocket* clientSocket) ;
/**
Desconecta el conector externo de este comunicador. Supone que todas las operaciones
\warning Exclusivamente uso interno
*/
- void detach(Handler* handler) throw();
+ void detach(Handler* handler) ;
/**
Devuelve el manejador asociado al ClientSocket recibido como parametro.
\param clientSocket Socket cliente del que queremos obtener en handler.
\return El manejador asociado al socket recibido como parametro. Puede ser NULL.
*/
- const Handler* getHandler(const ClientSocket& clientSocket) throw(RuntimeException);
+ const Handler* getHandler(const ClientSocket& clientSocket) noexcept(false);
/**
El thread que invoca a este Metodo entra en un proceso continuo de comprobacin/recepcin
traves de los Metodos manejadores de eventos de esta misma clase.
El thread saldra de este bucle tras la invocacion del Metodo #requestStop.
*/
- void accept() throw(RuntimeException);
+ void accept() noexcept(false);
/**
Solicita la parada de este comunicador.
*/
- void requestStop() throw();
+ void requestStop() ;
/**
Devuelve \em true si el ClientSocket recibido como parametro sigue siendo valido o \em false
\return \em true si el ClientSocket recibido como parametro sigue siendo valido o \em false
en caso de que haya dejado de ser valido debido al cierre del extremo remoto, por ejemplo.
*/
- bool isUsable(const ClientSocket* clientSocket) throw();
+ bool isUsable(const ClientSocket* clientSocket) ;
/**
Devuelve el numero handlers activos.
\return el numero handlers activos.
*/
- int handler_size() const throw() { return a_handlers.size(); }
+ int handler_size() const { return a_handlers.size(); }
/**
Devuelve un iterador que apunta el primer controlador.
\return un iterador que apunta el primer controlador.
*/
- handler_iterator handler_begin() throw() { return a_handlers.begin(); }
+ handler_iterator handler_begin() { return a_handlers.begin(); }
/**
Devuelve un iterador que apunta al final de la lista de controladores.
\return un iterador que apunta al final de la lista de controladores.
*/
- handler_iterator handler_end() throw() { return a_handlers.end(); }
+ handler_iterator handler_end() { return a_handlers.end(); }
/**
Devuelve un iterador que apunta el primer controlador.
\return un iterador que apunta el primer controlador.
*/
- const_handler_iterator handler_begin() const throw() { return a_handlers.begin(); }
+ const_handler_iterator handler_begin() const { return a_handlers.begin(); }
/**
Devuelve un iterador que apunta al final de la lista de controladores.
\return un iterador que apunta al final de la lista de controladores.
*/
- const_handler_iterator handler_end() const throw() { return a_handlers.end(); }
+ const_handler_iterator handler_end() const { return a_handlers.end(); }
/**
Devuelve un iterador que apunta el primer servicio.
\return un iterador que apunta el primer service.
*/
- const_service_iterator service_begin() const throw() { return a_services.begin(); }
+ const_service_iterator service_begin() const { return a_services.begin(); }
/**
Devuelve un iterador que apunta al final de la lista de servicios.
\return un iterador que apunta al final de la lista de servicios.
*/
- const_service_iterator service_end() const throw() { return a_services.end(); }
+ const_service_iterator service_end() const { return a_services.end(); }
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador ante
\warning Este Metodo no debera generar ningn tipo de excepcin.
*/
- virtual void eventUser(const char* id, const void* context) throw() {;}
+ virtual void eventUser(const char* id, const void* context) {;}
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
\li El nucleo de ANNA.comm necesita conocer este evento por lo que cualquier implementacin
debera invocar al Metodo eventBreakAddress de su clase base.
*/
- virtual void eventBreakAddress(const in_addr_t& address) throw();
+ virtual void eventBreakAddress(const in_addr_t& address) ;
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
\li El nucleo de ANNA.comm necesita conocer este evento por lo que cualquier implementacin
debera invocar al Metodo eventRecoverAddress de su clase base.
*/
- virtual void eventRecoverAddress(const in_addr_t& address) throw();
+ virtual void eventRecoverAddress(const in_addr_t& address) ;
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
\warning Desde ANNA.comm 1.11.18 se mide el nivel de carga del proceso y si se evalúa como
congestionado no permitirá aceptar la nueva conexión.
*/
- virtual bool eventAcceptConnection(const ClientSocket& clientSocket) throw(RuntimeException);
+ virtual bool eventAcceptConnection(const ClientSocket& clientSocket) noexcept(false);
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
\see Host::createServer
*/
- virtual void eventCreateConnection(const Server* server) throw();
+ virtual void eventCreateConnection(const Server* server) ;
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
\see Host::createServer
*/
- virtual void eventCreateConnection(const Service* service) throw();
+ virtual void eventCreateConnection(const Service* service) ;
/**
Establece las acciones a realizar cuando la clase Communicator detecta la llegada de un
en entorno MT.
*/
virtual void eventReceiveMessage(ClientSocket& clientSocket, const Message& message)
- throw(RuntimeException) { ; }
+ noexcept(false) { ; }
/**
Establece las acciones a realizar cuando el nucleo de ANNA.comm notifica que ha
cerrado un anna::comm::ClientSocket debido a un consumo excesivo de memoria.
\param clientSocket Socket cliente que va a ser cerrado por el nucleo de ANNA.comm.
*/
- virtual void eventOverQuota(const ClientSocket& clientSocket) throw() {;}
+ virtual void eventOverQuota(const ClientSocket& clientSocket) {;}
/**
Establece las acciones a realizar cuando el núcleo de ANNA.comm notifica que ha
ha sido analizado correctamente.
\param clientSocket Socket cliente que va a ser cerrado por el nucleo de ANNA.comm.
*/
- virtual void eventDiscardConnection(const ClientSocket& clientSocket) throw() {;}
+ virtual void eventDiscardConnection(const ClientSocket& clientSocket) {;}
/**
* Método manejador invocado cuando un client socket que tiene activado el indicador de ignorar los
* \param clientSocket ClientSocket por el que se recibe el mensaje.
* \param burst Bloque de datos que contiene la trama recibida.
*/
- virtual void eventIgnoreBurst(const ClientSocket& clientSocket, const DataBlock& burst) throw() {;}
+ virtual void eventIgnoreBurst(const ClientSocket& clientSocket, const DataBlock& burst) {;}
/**
Devuelve una cadena con la informacion mas relevante de esta instancia.
\return Una cadena con la informacion mas relevante de esta instancia.
*/
- std::string asString() const throw();
+ std::string asString() const ;
/**
Devuelve un documento XML con la informacion mas relevante de esta instancia.
\param parent Nodo XML del que colgar la informacion referente a esta instancia.
\return Un documento XML con la informacion mas relevante de esta instancia.
*/
- virtual xml::Node* asXML(xml::Node* parent) const throw();
+ virtual xml::Node* asXML(xml::Node* parent) const ;
/**
Devuelve el controlador apuntado por el iterador recibido.
\param ii Iterador con el que estamos recorriendo los controladores.
\return el controlador apuntado por el iterador recibido.
*/
- static Handler* handler(handler_iterator& ii) throw() { return Handlers::data(ii); }
+ static Handler* handler(handler_iterator& ii) { return Handlers::data(ii); }
/**
Devuelve el controlador apuntado por el iterador recibido.
\param ii Iterador con el que estamos recorriendo los controladores.
\return el controlador apuntado por el iterador recibido.
*/
- static const Handler* handler(const_handler_iterator& ii) throw() { return Handlers::data(ii); }
+ static const Handler* handler(const_handler_iterator& ii) { return Handlers::data(ii); }
/**
Devuelve el servicio apuntado por el iterador recibido.
\param ii Iterador con el que estamos recorriendo los servicios.
\return el servicio apuntado por el iterador recibido.
*/
- static const Service* service(const_service_iterator& ii) throw() { return *ii; }
+ static const Service* service(const_service_iterator& ii) { return *ii; }
/**
Devuelve la cadena por la que podemos buscar el componente.
que despues de este Metodo esta instancia no debera utilizarse.
\warning Estado MT: \code [Tx] -> Communicator \endcode
*/
- virtual void eventBreakConnection(const ClientSocket& clientSocket) throw() {;}
+ virtual void eventBreakConnection(const ClientSocket& clientSocket) {;}
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
@param clientSocket Socket cliente asociado a esta rotura de conexion.
*/
- virtual void eventBreakLocalConnection(const ClientSocket& clientSocket) throw() {;}
+ virtual void eventBreakLocalConnection(const ClientSocket& clientSocket) {;}
/**
@param server Proceso servidor con el que hemos perdido la conexion.
*/
- virtual void eventBreakConnection(const Server* server) throw();
+ virtual void eventBreakConnection(const Server* server) ;
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador
\param service Servicio que ha dejado de estar disponible.
\warning Estado MT: \code [Tx] -> Communicator \endcode
*/
- virtual void eventBreakConnection(const Service* service) throw();
+ virtual void eventBreakConnection(const Service* service) ;
/**
Establecer la configuracin de este comunicador. El cargador de configuracin se encarga de establecer
\warning Este Metodo debe invocarse desde las clases heredadas.
*/
- virtual void do_initialize() throw(RuntimeException) {;}
+ virtual void do_initialize() noexcept(false) {;}
/**
Solicita la parada de este comunicador. Se reimplementa para mantener el interfaz de la clase
Component de la que hereda este Communicator.
*/
- void do_stop() throw() { requestStop(); }
+ void do_stop() { requestStop(); }
/**
Establece el estado de este proceso con respecto al sistema de comunicaciones
@param status Estado del sistema de comunicaciones que deseamos establecer.
*/
- virtual void setStatus(const Status& status) throw();
+ virtual void setStatus(const Status& status) ;
/**
Establece la conexion entre el comunicador y un socket dedicado a la comparticion de una
\internal
*/
- void attach(BinderSocket* binderSocket) throw(RuntimeException);
+ void attach(BinderSocket* binderSocket) noexcept(false);
/**
Desconecta el BinderSocket que fue previamente conectado con attach(BinderSocket*).
\param binderSocket Instancia del BinderSocket a desconectar.
\warning Exclusivamente uso interno
*/
- void detach(BinderSocket* binderSocket) throw();
+ void detach(BinderSocket* binderSocket) ;
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
todas las operaciones necesarias.
*/
- virtual void eventStartup() throw(RuntimeException) {;}
+ virtual void eventStartup() noexcept(false) {;}
/**
Metodo manejador de evento que permite ajustar el funcionamiento de nuestro comunicador cuando
En la mayoria de los casos no sera necesario indicar ninguna accion ya que ANNA.comm realiza
todas las operaciones necesarias.
*/
- virtual void eventShutdown() throw();
+ virtual void eventShutdown() ;
private:
const WorkMode::_v a_workMode;
// ST
Poll* a_poll;
Handlers a_timedouts;
- void singlethreadedAccept() throw(RuntimeException);
+ void singlethreadedAccept() noexcept(false);
// MT
ThreadManager* a_threadManager;
- void multithreadedAccept() throw(RuntimeException);
+ void multithreadedAccept() noexcept(false);
- ConnectionRecover* getConnectionRecover() throw() { return a_connectionRecover; }
+ ConnectionRecover* getConnectionRecover() { return a_connectionRecover; }
- void attach(RemoteConnection* remoteConnection) throw(RuntimeException);
+ void attach(RemoteConnection* remoteConnection) noexcept(false);
- void insert(Handler*) throw(RuntimeException);
- Handler* find(const int fd) throw() { return a_handlers.find(fd); }
+ void insert(Handler*) noexcept(false);
+ Handler* find(const int fd) { return a_handlers.find(fd); }
// Reimplementado de app::Component
- void do_cloneParent() throw(RuntimeException);
- void do_cloneChild() throw();
+ void do_cloneParent() noexcept(false);
+ void do_cloneChild() ;
friend class Handler;
projects / anna.git / blobdiff