Module.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_core_oam_Module_hpp
#define anna_core_oam_Module_hpp


// STL
#include <string>
#include <vector>
#include <map>

#include <anna/core/RuntimeException.hpp>

#include <anna/core/oam/defines.hpp>
#include <anna/core/oam/Handler.hpp>

#include <cstdarg>


namespace anna {
namespace xml {
class Node;
}
namespace oam {
class CounterScope;
class CounterRecorder;
}
}


namespace anna {

namespace oam {

class Handler;

class Module {

  Handler a_defaultHandler;        // default OAM handler
  Handler *a_handler;              // Handler reference
  std::string a_name;         // module description

  bool a_counters_enabled;         // Enable/Disable registered counters over this module (default is 'false')
  bool a_alarms_enabled;           // Enable/Disable registered alarms over this module (default is 'false')

  // GENERIC COUNTERS
  anna::oam::CounterScope* a_active_counter_scope; // Current scope for counters generation
  typedef std::map <int, anna::oam::CounterScope*> scope_container;
  scope_container a_scopes; // Module can manage N scope clones (usually, there is only one registered scope: mono-context applications)
  typedef std::map < int /*type*/, counter_data_t > counter_container;
  counter_container a_counters;

  // GENERIC ALARMS
  typedef std::map < int /*type*/, alarm_data_t > alarm_container;
  alarm_container a_alarms;
  void alarmEvent(bool activation, const int & type, va_list argList) const ;

  // dynamic modifications over alarm text
  bool a_alarms_preffix_enabled;   // Show own module alarm preffix
  bool a_alarms_suffix_enabled;    // Show own module alarm suffix
  std::string alarmComponentsToText(const std::vector<std::string> & components, const std::string & psL, const std::string & psS, const std::string & psR) const ;

  // Counters
  typedef scope_container::iterator scope_iterator;
  typedef scope_container::const_iterator const_scope_iterator;
  scope_iterator scope_find(const int &key) { return a_scopes.find(key); }
  scope_iterator scope_begin() { return a_scopes.begin(); }
  scope_iterator scope_end() { return a_scopes.end(); }
  static anna::oam::CounterScope* scope(scope_iterator ii) { return ii->second; }
  const_scope_iterator scope_begin() const { return a_scopes.begin(); }
  const_scope_iterator scope_end() const { return a_scopes.end(); }
  static const anna::oam::CounterScope* scope(const_scope_iterator ii) { return ii->second; }
  anna::oam::CounterScope *getScope(const int &id) ;
  typedef counter_container::iterator counter_iterator;
  typedef counter_container::const_iterator const_counter_iterator;
//   bool counter_remove(const int &key) ;
  const_counter_iterator counter_find(const int &key) const { return a_counters.find(key); }
  const_counter_iterator counter_begin() const { return a_counters.begin(); }
  const_counter_iterator counter_end() const { return a_counters.end(); }
  counter_iterator counter_find(const int &key) { return a_counters.find(key); }
  counter_iterator counter_begin() { return a_counters.begin(); }
  counter_iterator counter_end() { return a_counters.end(); }
  CounterRecorder* a_counterRecorder;
  bool a_counterRecording;

  class RecordingGuard {
    public:
      RecordingGuard(Module*);
      ~RecordingGuard();
    private:
      Module *a_module;
  };

  // Alarms
  typedef alarm_container::iterator alarm_iterator;
  typedef alarm_container::const_iterator const_alarm_iterator;
//   bool alarm_remove(const int &key) ;
  const_alarm_iterator alarm_find(const int &key) const { return a_alarms.find(key); }
  const_alarm_iterator alarm_begin() const { return a_alarms.begin(); }
  const_alarm_iterator alarm_end() const { return a_alarms.end(); }
  alarm_iterator alarm_find(const int &key) { return a_alarms.find(key); }
  alarm_iterator alarm_begin() { return a_alarms.begin(); }
  alarm_iterator alarm_end() { return a_alarms.end(); }
  void getAlarmPreffixSuffixAndZoneSeparator(std::string & preffix, std::string & suffix, char & zS) const ;

public:

  static const int MaxScope = 1000; 
  Module(const std::string &name) :
    a_handler(&a_defaultHandler),
    a_name(name),
    a_counters_enabled(false),
    a_alarms_enabled(false),
    a_alarms_preffix_enabled(true),
    a_alarms_suffix_enabled(true),
    a_counterRecorder(NULL),
    a_counterRecording(false) {;}

  virtual ~Module();

  int scopes() const { return a_scopes.size(); }

  void enableCounters(void) ;

  void disableCounters(void) ;

  void enableAlarms(void) ;

  void disableAlarms(void) ;

  bool countersEnabled() const { return a_counters_enabled; }

  bool alarmsEnabled() const { return a_alarms_enabled; }

  void enableAlarmsPreffix(void) ;

  void enableAlarmsSuffix(void) ;

  void disableAlarmsPreffix(void) ;

  void disableAlarmsSuffix(void) ;

  void setHandler(Handler *handler) { if(handler) a_handler = handler; }

  void initializeCounterScope(const int & scopeId, const std::string & description = "") noexcept(false);


  void setActiveCounterScope(const int & scopeId) ;


  const anna::oam::CounterScope* getActiveCounterScope() const { return a_active_counter_scope; }

  virtual std::string getDefaultInternalAlarmDescription(const int & type) const ;

  virtual std::string getDefaultInternalCounterDescription(const int & type) const ;


  void registerCounter(const int &type, const std::string &description, const int &offset) noexcept(false);


  void registerAlarm(const int &type, const std::string &description, const int &externalId, const std::string &dynamicVariablesCSL, const int &activationId, const int &cancellationId = -1) noexcept(false);


  const char *getName() const { return a_name.c_str(); }


  const counter_data_t *counter(const int &type) const {
    const_counter_iterator it = counter_find(type);
    return ((it != counter_end()) ? (&(*it).second) : NULL);
  }

  const alarm_data_t *alarm(const int &type) const {
    const_alarm_iterator it = alarm_find(type);
    return ((it != alarm_end()) ? (&(*it).second) : NULL);
  }


  void count(const int & type, const int & amount = 1) noexcept(false);


  int resetCounters(const int & scopeId = -1) ;


  void setCounterRecorder(CounterRecorder* counterRecorder) { a_counterRecorder = counterRecorder; }

  void recordCounters() noexcept(false);


  void activateAlarm(int type, ...) const noexcept(false);


  void cancelAlarm(int type, ...) const noexcept(false);


  virtual std::string asString(void) const ;


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


protected:

  virtual void readAlarmPreffixComponents(std::vector<std::string> & components) const {;}


  virtual void readAlarmSuffixComponents(std::vector<std::string> & components) const {;}


  friend class RecordingGuard;
};

}
}

#endif