Application.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_app_Application_hpp
#define anna_app_Application_hpp

#include <vector>

#include <anna/core/RuntimeException.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace app {

class Component;
struct functions;

class Application {
public:
  typedef std::vector <Component*>::iterator iterator;
  typedef std::vector <Component*>::const_iterator const_iterator;
  typedef std::vector <pid_t> pid_container;
  typedef pid_container::iterator pid_iterator;
  typedef pid_container::const_iterator const_pid_iterator;

  Application(const char* shortName, const char* title, const char* version, const char* date = NULL, const char* time = NULL);

  virtual ~Application() { a_components.clear(); }

  // Getters
  const char* getShortName() const { return a_shortName; }

  const std::string& getVersion() const { return a_version; }

  const std::string& getTitle() const { return a_title; }

  pid_t getPid() const { return a_pid; }

  void activateGeneralPublicLicense() { a_enableGPL = true; }

  Application& clone() noexcept(false);

  Component* find(const char* className) ;

  void start() noexcept(false);

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

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

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

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

  void writeContext(const std::string& file) noexcept(false);

  virtual void initialize() noexcept(false) {;}

  virtual bool supportCommunication() const { return false; }

  virtual void eventAbnormalTermination(const char* className) { ; }

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

  static const Component* component(const_iterator& ii) { return *ii; }

  static Component* component(iterator& ii) { return *ii; }

protected:
  static Application* st_application;

  virtual void run() noexcept(false) = 0;

  virtual void signalUSR1() noexcept(false);

  virtual void signalUSR2() noexcept(false);

  virtual void signalTerminate() noexcept(false) {;}

  virtual void do_cloneParent() noexcept(false) {;}

  virtual void do_cloneChild() noexcept(false) {;}

  pid_iterator pid_begin() { return a_pids.begin(); }

  pid_iterator pid_end() { return a_pids.end(); }

  int pid_size() const { return a_pids.size(); }

  const_pid_iterator pid_begin() const { return a_pids.begin(); }

  const_pid_iterator pid_end() const { return a_pids.end(); }

  static pid_t pid(pid_iterator& ii) { return *ii; }

  static pid_t pid(const_pid_iterator& ii) { return *ii; }

private:
  const std::string a_title;
  std::vector <Component*> a_components;
  pid_t a_pid;
  const char* a_shortName;
  bool a_running;
  std::string a_version;
  bool a_enableGPL;
  pid_container a_pids;

  void attach(Component*) noexcept(false);
  void detach(Component*) noexcept(false);

  void startComponents() noexcept(false);
  void stopComponents() noexcept(false);
  void sendSignalToChilds(const int signal) ;

  void signalUSR(int) noexcept(false);
  static void handlerSignalUSR(int) ;
  static void handlerSignalTerminate(int) ;
  static void handlerChildTerminate(int sig) ;

  friend class Component;  // Para poder acceder a los metodo attach y detach
  friend struct functions;
};

}
}

#endif