-// ANNA - Anna is Not 'N' Anymore
-//
-// (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
-//
-// https://bitbucket.org/testillano/anna
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Authors: eduardo.ramos.testillano@gmail.com
-// cisco.tierra@gmail.com
+// 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
#include <anna/core/oam/defines.hpp>
#include <anna/core/oam/Handler.hpp>
+#include <cstdarg>
+
namespace anna {
namespace xml {
}
namespace oam {
class CounterScope;
+class CounterRecorder;
}
}
Handler a_defaultHandler; // default OAM handler
Handler *a_handler; // Handler reference
+ std::string a_name; // module description
- std::string a_className; // module description
- bool a_counters_enabled; // Enable/Disable registered counters over this module (default is 'true')
- bool a_alarms_enabled; // Enable/Disable registered alarms over this module (default is 'true')
-
- // 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 throw();
+ 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
// 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 ;
- void alarmEvent(bool activation, const int & type, va_list argList) const throw();
+ // 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) throw() { return a_scopes.find(key); }
- scope_iterator scope_begin() throw() { return a_scopes.begin(); }
- scope_iterator scope_end() throw() { return a_scopes.end(); }
- static anna::oam::CounterScope* scope(scope_iterator ii) throw() { return ii->second; }
- const_scope_iterator scope_begin() const throw() { return a_scopes.begin(); }
- const_scope_iterator scope_end() const throw() { return a_scopes.end(); }
- static const anna::oam::CounterScope* scope(const_scope_iterator ii) throw() { return ii->second; }
- anna::oam::CounterScope *getScope(const int &id) throw();
+ 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) throw();
- const_counter_iterator counter_find(const int &key) const throw() { return a_counters.find(key); }
- const_counter_iterator counter_begin() const throw() { return a_counters.begin(); }
- const_counter_iterator counter_end() const throw() { return a_counters.end(); }
- counter_iterator counter_find(const int &key) throw() { return a_counters.find(key); }
- counter_iterator counter_begin() throw() { return a_counters.begin(); }
- counter_iterator counter_end() throw() { return a_counters.end(); }
-
+// 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) throw();
- const_alarm_iterator alarm_find(const int &key) const throw() { return a_alarms.find(key); }
- const_alarm_iterator alarm_begin() const throw() { return a_alarms.begin(); }
- const_alarm_iterator alarm_end() const throw() { return a_alarms.end(); }
- alarm_iterator alarm_find(const int &key) throw() { return a_alarms.find(key); }
- alarm_iterator alarm_begin() throw() { return a_alarms.begin(); }
- alarm_iterator alarm_end() throw() { return a_alarms.end(); }
- void getAlarmPreffixSuffixAndZoneSeparator(std::string & preffix, std::string & suffix, char & zS) const throw();
-
+// 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; /**< Numero maximo de ambitos */
+
+
/** Constructor
- @param className Logical name for the class (better use fullNaming format including namespace resolution)
+ @param name Logical name for the class (better use fullNaming format including namespace resolution)
*/
- Module(const std::string &className) : a_className(className),
+ Module(const std::string &name) :
a_handler(&a_defaultHandler),
- a_counters_enabled(true),
- a_alarms_enabled(true),
+ a_name(name),
+ a_counters_enabled(false),
+ a_alarms_enabled(false),
a_alarms_preffix_enabled(true),
- a_alarms_suffix_enabled(true) {;}
-
+ a_alarms_suffix_enabled(true),
+ a_counterRecorder(NULL),
+ a_counterRecording(false) {;}
/**
* Destructor
*/
- virtual ~Module() {;}
+ virtual ~Module();
+ /**
+ * Number of scopes registered
+ */
+ int scopes() const { return a_scopes.size(); }
/**
* Enable all the counters registered in this module (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void enableCounters(void) throw();
+ void enableCounters(void) ;
/**
* Disable all the counters registered in this module (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void disableCounters(void) throw();
+ void disableCounters(void) ;
/**
* Enable all the alarms registered in this module (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void enableAlarms(void) throw();
+ void enableAlarms(void) ;
/**
* Disable all the alarms registered in this module (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void disableAlarms(void) throw();
+ void disableAlarms(void) ;
+
+ /**
+ Getter for counters enabled
+ */
+ bool countersEnabled() const { return a_counters_enabled; }
+
+ /**
+ Getter for alarms enabled
+ */
+ bool alarmsEnabled() const { return a_alarms_enabled; }
/**
* Show own module alarm preffix (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void enableAlarmsPreffix(void) throw();
+ void enableAlarmsPreffix(void) ;
/**
* Show own module alarm suffix (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void enableAlarmsSuffix(void) throw();
+ void enableAlarmsSuffix(void) ;
/**
* Hide own module alarm preffix (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void disableAlarmsPreffix(void) throw();
+ void disableAlarmsPreffix(void) ;
/**
* Hide own module alarm suffix (enabled by default at constructor).
* Usually managed at PROCCESS implementation
*/
- void disableAlarmsSuffix(void) throw();
+ void disableAlarmsSuffix(void) ;
/**
* Sets the operations handler. By default, all modules will use the default anna::oam::Handler.
*
* @param handler Handler used for OAM operations (registering and launch). NULL is ignored
*/
- void setHandler(Handler *handler) throw() { if(handler) a_handler = handler; }
+ void setHandler(Handler *handler) { if(handler) a_handler = handler; }
/**
* Counter scope registration. Usually, only one scope id will be registered, but multicontext applications
* better than 'Main OAM Module' for all of them. Also, you can use the same description for all scopes
* (that is the case of default assignment).
*/
- void initializeCounterScope(const int & scopeId, const std::string & description = "") throw(anna::RuntimeException);
+ void initializeCounterScope(const int & scopeId, const std::string & description = "") noexcept(false);
/**
*
* @param scopeId Counter scope id which becomes active.
*/
- void setActiveCounterScope(const int & scopeId) throw();
+ void setActiveCounterScope(const int & scopeId) ;
/**
*
* @return Activated counter scope
*/
- const anna::oam::CounterScope* getActiveCounterScope() const throw() { return a_active_counter_scope; }
+ const anna::oam::CounterScope* getActiveCounterScope() const { return a_active_counter_scope; }
/**
* Child oam module classes should define descriptions for each enum type. A good practice would be the use of
*
* @return Default alarm description
*/
- virtual std::string getDefaultInternalAlarmDescription(const int & type) const throw();
+ virtual std::string getDefaultInternalAlarmDescription(const int & type) const ;
/**
* Child oam module classes should define descriptions for each enum type. A good practice would be the use of
*
* @return Default counter description
*/
- virtual std::string getDefaultInternalCounterDescription(const int & type) const throw();
+ virtual std::string getDefaultInternalCounterDescription(const int & type) const ;
/**
* for non-registered will be searched (#getDefaultInternalCounterDescription).
* @param offset Counter offset over (1000 * scope id). Offset has 0-999 range.
*/
- void registerCounter(const int &type, const std::string &description, const int &offset) throw(anna::RuntimeException);
+ void registerCounter(const int &type, const std::string &description, const int &offset) noexcept(false);
/**
* @param activationId Alarm activation identifier
* @param cancellationId Alarm cancellation identifier. If missing, the alarm will interpreted as non-transferable
*/
- void registerAlarm(const int &type, const std::string &description, const int &externalId, const std::string &dynamicVariablesCSL, const int &activationId, const int &cancellationId = -1) throw(anna::RuntimeException);
+ 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);
/**
@param OAM module name
*/
- const char *getClassName() const throw() { return a_className.c_str(); }
+ const char *getName() const { return a_name.c_str(); }
/**
@param type Alarm enum-identification within the own context/module.
*/
- const counter_data_t *counter(const int &type) const throw() {
+ const counter_data_t *counter(const int &type) const {
const_counter_iterator it = counter_find(type);
return ((it != counter_end()) ? (&(*it).second) : NULL);
}
@param type Counter enum-identification within the own context/module.
*/
- const alarm_data_t *alarm(const int &type) const throw() {
+ const alarm_data_t *alarm(const int &type) const {
const_alarm_iterator it = alarm_find(type);
return ((it != alarm_end()) ? (&(*it).second) : NULL);
}
* @param type Counter enum-identification within the own context/module
* @param amount Units increased. Default is 1
*/
- void count(const int & type, const int & amount = 1) throw(anna::RuntimeException);
+ void count(const int & type, const int & amount = 1) noexcept(false);
/**
*
* @return Number of affected counters which have been reset (only those which have non-zero accumulated count).
*/
- int resetCounters(const int & scopeId = -1) throw();
+ int resetCounters(const int & scopeId = -1) ;
+
+
+ /**
+ * Sets the instance for the class which will save the counters information.
+ * @counterRecorder Provided instance
+ * @warning It should be invoked periodically as a common solution
+ */
+ void setCounterRecorder(CounterRecorder* counterRecorder) { a_counterRecorder = counterRecorder; }
+
+ /**
+ * Dumps the modified counters from last invocation to this method.
+ * A counter recorder should have been assigned by mean setCounterRecorder(), which
+ * will have the specific behaviour. This procedure is oriented to have physical storage
+ * for counters information.
+ */
+ void recordCounters() noexcept(false);
/**
* @param alarmType Alarm enum-identification within the own context/module
* @param ... Optional parsing data for dynamic-composed text.
*/
- void activateAlarm(const int & type, ...) const throw(anna::RuntimeException);
+ void activateAlarm(int type, ...) const noexcept(false);
/**
* @param alarmType Alarm enum-identification within the own context/module
* @param ... Optional parsing data for dynamic-composed text.
*/
- void cancelAlarm(const int & type, ...) const throw(anna::RuntimeException);
+ void cancelAlarm(int type, ...) const noexcept(false);
/**
*
* @return String with class content
*/
- virtual std::string asString(void) const throw();
+ virtual std::string asString(void) const ;
/**
*
* @return XML with class content
*/
- virtual anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
+ virtual anna::xml::Node* asXML(anna::xml::Node* parent) const ;
protected:
*
* @param components Alarm preffix components defined by oam module. Empty on default implementation.
*/
- virtual void readAlarmPreffixComponents(std::vector<std::string> & components) const throw() {;}
+ virtual void readAlarmPreffixComponents(std::vector<std::string> & components) const {;}
/**
*
* @param components Alarm suffix components defined by oam module. Empty on default implementation.
*/
- virtual void readAlarmSuffixComponents(std::vector<std::string> & components) const throw() {;}
+ virtual void readAlarmSuffixComponents(std::vector<std::string> & components) const {;}
+
+
+ friend class RecordingGuard;
};
}
projects / anna.git / blobdiff