Programming answers in double ended queue. Fix word "Coding" by "Encoding"
[anna.git] / source / core / oam / Module.cpp
1 // ANNA - Anna is Not Nothingness Anymore
2 //
3 // (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
4 //
5 // http://redmine.teslayout.com/projects/anna-suite
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions
9 // are met:
10 //
11 //     * Redistributions of source code must retain the above copyright
12 // notice, this list of conditions and the following disclaimer.
13 //     * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following disclaimer
15 // in the documentation and/or other materials provided with the
16 // distribution.
17 //     *  Neither the name of the copyright holder nor the names of its
18 // contributors may be used to endorse or promote products derived from
19 // this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 //
33 // Authors: eduardo.ramos.testillano@gmail.com
34 //          cisco.tierra@gmail.com
35
36
37 // Local
38 #include <anna/core/oam/Module.hpp>
39 #include <anna/core/functions.hpp>
40 #include <anna/core/oam/Configuration.hpp>
41 #include <anna/core/oam/CounterScope.hpp>
42 #include <anna/core/oam/CounterRecorder.hpp>
43
44 #include <anna/core/tracing/Logger.hpp>
45 #include <anna/core/tracing/TraceWriter.hpp>
46 #include <anna/core/tracing/TraceMethod.hpp>
47 #include <anna/core/functions.hpp>
48 #include <anna/xml/xml.hpp>
49
50 // Standard
51 #include <cstdarg>
52
53
54 #define UNDEFINED_EVENT_DESCRIPTION "<undefined>"
55
56
57 //******************************************************************************
58 //----------------------------------------------------------------------- Module
59 //******************************************************************************
60
61 //------------------------------------------------------------------------------
62 //-------------------------------------------------------------- Module::~Module
63 //------------------------------------------------------------------------------
64 anna::oam::Module::~Module() {
65   for(scope_iterator scope_it = scope_begin(); scope_it != scope_end(); scope_it++)
66     delete (scope(scope_it));
67 }
68
69
70 //------------------------------------------------------------------------------
71 //----------------------------------------------------------- Module::getScope()
72 //------------------------------------------------------------------------------
73 anna::oam::CounterScope *anna::oam::Module::getScope(const int &id) throw() {
74   scope_iterator it = scope_find(id);
75   return ((it != scope_end()) ? scope(it) : NULL);
76 }
77
78 ////------------------------------------------------------------------------------
79 ////------------------------------------------------------- Module::alarm_remove()
80 ////------------------------------------------------------------------------------
81 //bool anna::oam::Module::alarm_remove(const int &key) throw() {
82 //   alarm_iterator it = alarm_find(key);
83 //   if (it != alarm_end()) {
84 //      a_alarms.erase(key);
85 //      return true;
86 //   }
87 //
88 //   return false;
89 //}
90 //
91 ////------------------------------------------------------------------------------
92 ////----------------------------------------------------- Module::counter_remove()
93 ////------------------------------------------------------------------------------
94 //bool anna::oam::Module::counter_remove(const int &key) throw() {
95 //   counter_iterator it = counter_find(key);
96 //   if (it != counter_end()) {
97 //      a_counters.erase(key);
98 //      return true;
99 //   }
100 //
101 //   return false;
102 //}
103
104
105 // public:
106
107
108 //------------------------------------------------------------------------------
109 //----------------------------------------------------- Module::enableCounters()
110 //------------------------------------------------------------------------------
111 void anna::oam::Module::enableCounters(void) throw() {
112   a_counters_enabled = true;
113   LOGDEBUG(anna::Logger::debug("Scoped counters ENABLED", ANNA_FILE_LOCATION));
114 }
115
116
117 //------------------------------------------------------------------------------
118 //---------------------------------------------------- Module::disableCounters()
119 //------------------------------------------------------------------------------
120 void anna::oam::Module::disableCounters(void) throw() {
121   a_counters_enabled = false;
122   LOGDEBUG(anna::Logger::debug("Scoped counters DISABLED", ANNA_FILE_LOCATION));
123 }
124
125
126 //------------------------------------------------------------------------------
127 //------------------------------------------------------- Module::enableAlarms()
128 //------------------------------------------------------------------------------
129 void anna::oam::Module::enableAlarms(void) throw() {
130   a_alarms_enabled = true;
131   LOGDEBUG(anna::Logger::debug("Scoped alarms ENABLED", ANNA_FILE_LOCATION));
132 }
133
134
135 //------------------------------------------------------------------------------
136 //------------------------------------------------------ Module::disableAlarms()
137 //------------------------------------------------------------------------------
138 void anna::oam::Module::disableAlarms(void) throw() {
139   a_alarms_enabled = false;
140   LOGDEBUG(anna::Logger::debug("Scoped alarms DISABLED", ANNA_FILE_LOCATION));
141 }
142
143
144 //------------------------------------------------------------------------------
145 //------------------------------------------------ Module::enableAlarmsPreffix()
146 //------------------------------------------------------------------------------
147 void anna::oam::Module::enableAlarmsPreffix(void) throw() {
148   a_alarms_preffix_enabled = true;
149   LOGDEBUG(anna::Logger::debug("Alarm preffix module components SHOWN", ANNA_FILE_LOCATION));
150 }
151
152
153 //------------------------------------------------------------------------------
154 //------------------------------------------------- Module::enableAlarmsSuffix()
155 //------------------------------------------------------------------------------
156 void anna::oam::Module::enableAlarmsSuffix(void) throw() {
157   a_alarms_suffix_enabled = true;
158   LOGDEBUG(anna::Logger::debug("Alarm suffix module components SHOWN", ANNA_FILE_LOCATION));
159 }
160
161
162 //------------------------------------------------------------------------------
163 //----------------------------------------------- Module::disableAlarmsPreffix()
164 //------------------------------------------------------------------------------
165 void anna::oam::Module::disableAlarmsPreffix(void) throw() {
166   a_alarms_preffix_enabled = false;
167   LOGDEBUG(anna::Logger::debug("Alarm preffix module components HIDDEN", ANNA_FILE_LOCATION));
168 }
169
170
171 //------------------------------------------------------------------------------
172 //------------------------------------------------ Module::disableAlarmsSuffix()
173 //------------------------------------------------------------------------------
174 void anna::oam::Module::disableAlarmsSuffix(void) throw() {
175   a_alarms_suffix_enabled = false;
176   LOGDEBUG(anna::Logger::debug("Alarm suffix module components HIDDEN", ANNA_FILE_LOCATION));
177 }
178
179
180 //------------------------------------------------------------------------------
181 //--------------------------------- Module::getDefaultInternalAlarmDescription()
182 //------------------------------------------------------------------------------
183 std::string anna::oam::Module::getDefaultInternalAlarmDescription(const int & type) const throw() {
184   return UNDEFINED_EVENT_DESCRIPTION;
185 }
186
187
188 //------------------------------------------------------------------------------
189 //------------------------------- Module::getDefaultInternalCounterDescription()
190 //------------------------------------------------------------------------------
191 std::string anna::oam::Module::getDefaultInternalCounterDescription(const int & type) const throw() {
192   return UNDEFINED_EVENT_DESCRIPTION;
193 }
194
195
196 //------------------------------------------------------------------------------
197 //---------------------------------------------- Module::alarmComponentsToText()
198 //------------------------------------------------------------------------------
199 std::string anna::oam::Module::alarmComponentsToText(const std::vector<std::string> & components, const std::string & psL, const std::string & psS, const std::string & psR) const throw() {
200   if(components.size() == 0) return ("");
201
202   std::vector<std::string>::const_iterator it_min(components.begin());
203   std::vector<std::string>::const_iterator it_max(components.end());
204   std::vector<std::string>::const_iterator it, it_last = it_max - 1;
205   std::string result = psL;
206
207   for(it = it_min; it != it_last; it++) { result += (*it); result += psS; }
208
209   result += (*it_last);
210   result += psR;
211   return (result);
212 }
213
214
215 //------------------------------------------------------------------------------
216 //------------------------------ Module::getAlarmPreffixSuffixAndZoneSeparator()
217 //------------------------------------------------------------------------------
218 void anna::oam::Module::getAlarmPreffixSuffixAndZoneSeparator(std::string & preffix, std::string & suffix, char & zS) const throw() {
219   Configuration &conf = Configuration::instantiate();
220   const std::vector<std::string> * globalPreffixComponents = conf.getAlarmPreffixComponents();
221   const std::vector<std::string> * globalSuffixComponents = conf.getAlarmSuffixComponents();
222   std::vector<std::string> preffixComponents, suffixComponents, compsAux;
223
224   if(globalPreffixComponents) preffixComponents = *globalPreffixComponents;
225
226   if(globalSuffixComponents) suffixComponents = *globalSuffixComponents;
227
228   if(a_alarms_preffix_enabled) {
229     // Read from virtual and append to global configuration ones:
230     readAlarmPreffixComponents(compsAux);
231
232     if(compsAux.size() != 0) preffixComponents.insert(preffixComponents.begin(), compsAux.begin(), compsAux.end());
233   }
234
235   if(a_alarms_suffix_enabled) {
236     // Read from virtual and append to global configuration ones:
237     compsAux.clear();
238     readAlarmSuffixComponents(compsAux);
239
240     if(compsAux.size() != 0) suffixComponents.insert(suffixComponents.begin(), compsAux.begin(), compsAux.end());
241   }
242
243   // Build final preffix and suffix from its components:
244   std::string psL, psS, psR;
245   conf.getAlarmTextDelimiters(zS, psL, psS, psR);
246   preffix = alarmComponentsToText(preffixComponents, psL, psS, psR);
247   suffix = alarmComponentsToText(suffixComponents, psL, psS, psR);
248 }
249
250
251
252
253 //------------------------------------------------------------------------------
254 //--------------------------------------------- Module::initializeCounterScope()
255 //------------------------------------------------------------------------------
256 void anna::oam::Module::initializeCounterScope(const int & scopeId, const std::string & description) throw(anna::RuntimeException) {
257   LOGMETHOD(anna::TraceMethod tttm("anna::oam::Module", "initializeCounterScope", ANNA_FILE_LOCATION));
258
259   // Order of use:
260   if(a_counters.size() != 0)  // any counter have been registered
261     throw anna::RuntimeException("After use of counter registration can't initialize more scope ids!. Do initializations firstly", ANNA_FILE_LOCATION);
262
263   // Scope range: 0 - 99
264   if(scopeId < 0 || scopeId >= MaxScope) {
265     std::string msg = "Scope Id must be in range [0 - ";
266     msg += anna::functions::asString(MaxScope - 1); // 99
267     msg += "]";
268     throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
269   }
270
271   // Check module scopes:
272   if(getScope(scopeId)) {
273     std::string msg = "Scope Id '";
274     msg += anna::functions::asString(scopeId);
275     msg += "' has already been registered in this module!";
276     throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
277   }
278
279   // Create scope:
280   bool missingScopeDescription = (description == "");
281   LOGWARNING(
282
283   if(missingScopeDescription && a_scopes.size() != 0) {
284   anna::Logger::warning("This is not the first initialized scope. Perhaps you should provide specific description better than general module name ...", ANNA_FILE_LOCATION);
285   }
286   );
287   const char * c_description = (missingScopeDescription ? getClassName() : description.c_str());
288   a_active_counter_scope = new CounterScope(scopeId, c_description);
289   a_scopes[scopeId] = a_active_counter_scope;
290 }
291
292
293 //------------------------------------------------------------------------------
294 //---------------------------------------------- Module::setActiveCounterScope()
295 //------------------------------------------------------------------------------
296 void anna::oam::Module::setActiveCounterScope(const int & scopeId) throw() {
297   anna::oam::CounterScope *scope = getScope(scopeId);
298
299   if(!scope) {
300     anna::Logger::error(anna::functions::asString("Provided scope id '%d' can't be activated, because you must initialize it first", scopeId), ANNA_FILE_LOCATION);
301     return;
302   }
303
304   a_active_counter_scope = scope;
305 }
306
307
308 //------------------------------------------------------------------------------
309 //---------------------------------------------------- Module::registerCounter()
310 //------------------------------------------------------------------------------
311 void anna::oam::Module::registerCounter(const int & type, const std::string & description, const int & offset) throw(anna::RuntimeException) {
312   // Handler-specific
313   a_handler->registerCounter(this, type, description, offset);
314
315   // Order of use:
316   if(a_scopes.size() == 0)  // at least one scope must be initialized
317     throw anna::RuntimeException("Before counter registration, at least one counter scope must be initialized at oam module", ANNA_FILE_LOCATION);
318
319   // Check type existence:
320   const_counter_iterator counter_it = counter_find(type);
321
322   if(counter_it != counter_end()) {
323     std::string msg = "There is a former counter registered with enum value (counter type) = ";
324     msg += anna::functions::asString(type);
325     throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
326   }
327
328   // If description is empty, get the default defined
329   std::string _description = ((description != "") ? description : getDefaultInternalCounterDescription(type));
330   counter_data_t aux;
331   aux.Offset = offset;
332   aux.Description = _description;
333   // Register for all initialized scopes:
334
335   for(scope_iterator scope_it = scope_begin(); scope_it != scope_end(); scope_it++) {
336     int scopeId = (*scope_it).first;
337     anna::oam::CounterScope * counterScope = scope(scope_it);
338     counterScope->create(offset, _description.c_str());
339     LOGDEBUG
340     (
341       std::string msg = "Added counter '";
342       msg += _description;
343       msg += "' over scope '";
344       msg += counterScope->getName();
345       msg += "': ScopeId/Offset [RealCounterId] = ";
346       msg += anna::functions::asString(scopeId); msg += "/";
347       msg += anna::functions::asString(offset); msg += " [";
348       msg += anna::functions::asString((scopeId * anna::oam::CounterScope::MaxCounter) + offset); msg += "]";
349       anna::Logger::debug(msg, ANNA_FILE_LOCATION);
350     );
351   }
352
353   a_counters[type] = aux;
354 }
355
356
357
358 //------------------------------------------------------------------------------
359 //------------------------------------------------------ Module::registerAlarm()
360 //------------------------------------------------------------------------------
361 void anna::oam::Module::registerAlarm(const int & type, const std::string &description, const int & externalId, const std::string & dynamicVariablesCSL, const int & activationId, const int & cancellationId) throw(anna::RuntimeException) {
362   // Handler-specific
363   a_handler->registerAlarm(this, type, description, externalId, dynamicVariablesCSL, activationId, cancellationId);
364   // Check type existence:
365   const_alarm_iterator alarm_it = alarm_find(type);
366
367   if(alarm_it != alarm_end()) {
368     std::string msg = "There is a former alarm registered with enum value (alarm type) = ";
369     msg += anna::functions::asString(type);
370     throw anna::RuntimeException(msg, ANNA_FILE_LOCATION);
371   }
372
373   // If description is empty, get the default defined
374   std::string _description = ((description != "") ? description : getDefaultInternalAlarmDescription(type));
375   alarm_data_t aux;
376   aux.ExternalId = externalId;
377   aux.DynamicVariablesCSL = dynamicVariablesCSL;
378   aux.ActivationId = activationId;
379   aux.CancellationId = cancellationId;
380   aux.Description = _description;
381   a_alarms[type] = aux;
382   LOGDEBUG
383   (
384     std::string msg = "Added alarm '";
385     msg += _description;
386     msg += "': externalId[dynamicVariablesCSL]/activationId";
387
388     if(cancellationId != -1) msg += "/cancellationId";
389     msg += " = ";
390     msg += anna::functions::asString(externalId); msg += "[";
391     msg += anna::functions::asString(dynamicVariablesCSL); msg += "]/";
392     msg += anna::functions::asString(activationId);
393   if(cancellationId != -1) {
394     msg += "/";
395     msg += anna::functions::asString(cancellationId);
396     }
397   anna::Logger::debug(msg, ANNA_FILE_LOCATION);
398   );
399 }
400
401
402 //------------------------------------------------------------------------------
403 //------------------------------------------------------ Module::activateAlarm()
404 //------------------------------------------------------------------------------
405 void anna::oam::Module::alarmEvent(bool activation, const int & type, va_list argList) const throw() {
406   // Preffix/Suffix and separator:
407   std::string userPreffix, userSuffix; char separator;
408   getAlarmPreffixSuffixAndZoneSeparator(userPreffix, userSuffix, separator);
409   const char *preffix = ((userPreffix != "") ? userPreffix.c_str() : NULL);
410   const char *suffix = ((userSuffix != "") ? userSuffix.c_str() : NULL);
411   va_list ap;
412   va_copy(ap, argList); // http://julipedia.meroh.net/2011/09/using-vacopy-to-safely-pass-ap.html
413   a_handler->alarmEvent(this, preffix, suffix, separator, activation, type, ap);
414   va_end(ap);
415 }
416
417
418 //------------------------------------------------------------------------------
419 //------------------------------------------------------ Module::activateAlarm()
420 //------------------------------------------------------------------------------
421 void anna::oam::Module::activateAlarm(int type, ...) const throw(anna::RuntimeException) {
422 //   LOGMETHOD(anna::TraceMethod tttm("anna::oam::Module", "activateAlarm", ANNA_FILE_LOCATION));
423
424   // Checkings
425   if(!a_alarms_enabled) {
426     LOGDEBUG
427     (
428       std::string msg = "Alarm activation ignored over module '";
429       msg += getClassName();
430       msg += "': alarms are disabled";
431       anna::Logger::debug(msg, ANNA_FILE_LOCATION);
432     );
433     return;
434   }
435
436   // User alarm event
437   va_list argList;
438   va_start(argList, type);
439   alarmEvent(true, type, argList);
440   va_end(argList);
441 }
442
443
444 //------------------------------------------------------------------------------
445 //-------------------------------------------------------- Module::cancelAlarm()
446 //------------------------------------------------------------------------------
447 void anna::oam::Module::cancelAlarm(int type, ...) const throw(anna::RuntimeException) {
448 //   LOGMETHOD(anna::TraceMethod tttm("anna::oam::Module", "cancelAlarm", ANNA_FILE_LOCATION));
449
450   // Checkings
451   if(!a_alarms_enabled) {
452     LOGDEBUG
453     (
454       std::string msg = "Alarm cancellation ignored over module '";
455       msg += getClassName();
456       msg += "': alarms are disabled";
457       anna::Logger::debug(msg, ANNA_FILE_LOCATION);
458     );
459     return;
460   }
461
462   // User alarm event
463   va_list argList;
464   va_start(argList, type);
465   alarmEvent(false, type, argList);
466   va_end(argList);
467 }
468
469
470 //------------------------------------------------------------------------------
471 //-------------------------------------------------------------- Module::count()
472 //------------------------------------------------------------------------------
473 void anna::oam::Module::count(const int & type, const int & amount) throw(anna::RuntimeException) {
474 //   LOGMETHOD(anna::TraceMethod tttm("anna::oam::Module", "count", ANNA_FILE_LOCATION));
475
476   // Checkings
477   if(!a_counters_enabled) {
478     LOGDEBUG
479     (
480       std::string msg = "Count operation ignored over module '";
481       msg += getClassName();
482       msg += "': counters are disabled";
483       anna::Logger::debug(msg, ANNA_FILE_LOCATION);
484     );
485     return;
486   }
487
488   a_handler->counterEvent(this, type, amount);
489 }
490
491
492 //------------------------------------------------------------------------------
493 //------------------------------------------------------ Module::resetCounters()
494 //------------------------------------------------------------------------------
495 int anna::oam::Module::resetCounters(const int & scopeId) throw() {
496   LOGMETHOD(anna::TraceMethod tttm("anna::oam::Module", "resetCounters", ANNA_FILE_LOCATION));
497   int result = 0; // affected number
498
499   for(scope_iterator scope_it = scope_begin(); scope_it != scope_end(); scope_it++)
500     result += scope(scope_it)->resetAccValues();
501
502   return result;
503 }
504
505
506 //------------------------------------------------------------------------------
507 //------------------------------------- Module::RecordingGuard::RecordingGuard()
508 //------------------------------------------------------------------------------
509 anna::oam::Module::RecordingGuard::RecordingGuard(anna::oam::Module* module) :
510   a_module(module) {                                                
511   module->a_counterRecording = true;                                               
512 }                                                                                   
513                                                                                     
514
515 //------------------------------------------------------------------------------
516 //------------------------------------ Module::RecordingGuard::~RecordingGuard()
517 //------------------------------------------------------------------------------
518 anna::oam::Module::RecordingGuard::~RecordingGuard() {                            
519   a_module->a_counterRecording = false;                                            
520 }                                                                                   
521
522
523 //------------------------------------------------------------------------------
524 //----------------------------------------------------- Module::recordCounters()
525 //------------------------------------------------------------------------------
526 void anna::oam::Module::recordCounters() throw(anna::RuntimeException) {
527   LOGMETHOD(anna::TraceMethod tttm("anna::oam::Module", "recordCounters", ANNA_FILE_LOCATION));
528
529   if(a_counterRecorder == NULL)
530     throw RuntimeException("anna::oam::Module has no counter recorder associated", ANNA_FILE_LOCATION);
531
532   LOGDEBUG(
533     std::string msg("Recording counters | ");
534     msg += a_counterRecorder->asString();
535     anna::Logger::write(Logger::Debug, msg, ANNA_FILE_LOCATION)
536   );
537   RecordingGuard guard(this);
538
539   a_counterRecorder->open();
540   Counter* counter = NULL;
541   CounterScope* cscope = NULL;
542
543   try {
544     for(scope_iterator scope_it = scope_begin(); scope_it != scope_end(); scope_it++) {
545       cscope = scope(scope_it);
546       if(cscope == NULL) continue;
547
548       Guard csGuard(cscope, "oam::CounterScope from oam::Module::record");
549
550       for(int icounter = 0; icounter < CounterScope::MaxCounter; icounter ++) {
551         Counter* counter = cscope->a_counters [icounter];
552
553         if(counter == NULL)
554           continue;
555
556         if(counter->getValue() == 0)
557           continue;
558
559         a_counterRecorder->apply(*counter);
560         counter->reset();
561       }
562     }
563
564     a_counterRecorder->close();
565   } catch(anna::RuntimeException&) {
566     a_counterRecorder->close();
567     throw;
568   }
569 }
570
571 //------------------------------------------------------------------------------
572 //----------------------------------------------------------- Module::asString()
573 //------------------------------------------------------------------------------
574 std::string anna::oam::Module::asString(void) const throw() {
575   std::string trace;
576   trace = "Module name: '";
577   trace += getClassName();
578   trace += "'";
579   trace += "\n\nCOUNTERS"; trace += "\n--------";
580   trace += "\nScoped counters "; trace += a_counters_enabled ? "Enabled" : "Disabled";
581   trace += "\nCounter Scopes: "; trace += anna::functions::asString(a_scopes.size());
582
583   for(const_scope_iterator scope_it = scope_begin(); scope_it != scope_end(); scope_it++) {
584     trace += "\n\nCounter Scope:";
585     int scopeId = (*scope_it).first;
586     trace += " Id: "; trace += anna::functions::asString(scopeId);
587     trace += " | Description: '"; trace += scope(scope_it)->getName(); trace += "'";
588     trace += "\nRegistered counters:\n";
589     counter_data_t * ptrCounterData;
590
591     for(const_counter_iterator cnt_it = counter_begin(); cnt_it != counter_end(); cnt_it++) {
592       ptrCounterData = (counter_data_t *) & ((*cnt_it).second);
593       // Counter:
594       trace += "\n\tType: "; trace += anna::functions::asString((*cnt_it).first);
595       trace += " | Description: '"; trace += ptrCounterData->Description; trace += "'";
596       int offset = ptrCounterData->Offset;
597       int realId = (1000 * scopeId) + offset;
598       trace += " | ScopeId/Offset: "; trace += anna::functions::asString(scopeId); trace += "/"; trace += anna::functions::asString(offset);
599       trace += " | RealId: "; trace += anna::functions::asString(realId);
600       unsigned long long int accValue = scope(scope_it)->getAccValue(offset);
601
602       if(accValue != 0ULL) {
603         trace += " | AccumulatedAmount: ";
604         trace += anna::functions::asString("%llu", accValue);
605       }
606     }
607   }
608
609   trace += "\n\nALARMS"; trace += "\n------";
610   trace += "\nScoped alarms "; trace += a_alarms_enabled ? "Enabled" : "Disabled";
611   trace += "\nPreffix alarm components: "; trace += a_alarms_preffix_enabled ? "Shown" : "Hidden";
612   trace += "\nSuffix alarm components: "; trace += a_alarms_suffix_enabled ? "Shown" : "Hidden";
613   trace += "\nRegistered alarms:\n";
614
615   for(const_alarm_iterator alrm_it = alarm_begin(); alrm_it != alarm_end(); alrm_it++) {
616     int cancellationId = (*alrm_it).second.CancellationId;
617     bool transferable = (cancellationId != -1);
618     trace += "\n\tType: "; trace += anna::functions::asString((*alrm_it).first);
619     trace += " | Description: '"; trace += (*alrm_it).second.Description;
620     trace += transferable ? "' [transferable alarm]" : "'";
621     trace += " | DatabaseId: "; trace += anna::functions::asString((*alrm_it).second.ExternalId);
622     trace += " | dynamicVariablesCSL: "; trace += (*alrm_it).second.DynamicVariablesCSL;
623     trace += " | ActivationId: "; trace += anna::functions::asString((*alrm_it).second.ActivationId);
624
625     if(transferable) { trace += " | CancellationId: "; trace += anna::functions::asString(cancellationId); }
626   }
627
628   return (trace);
629 }
630
631
632
633 //------------------------------------------------------------------------------
634 //-------------------------------------------------------------- Module::asXML()
635 //------------------------------------------------------------------------------
636 anna::xml::Node* anna::oam::Module::asXML(anna::xml::Node* parent) const throw() {
637   anna::xml::Node* result = parent->createChild("oam.Module");
638   result->createAttribute("Name", getClassName());
639   result->createAttribute("Counters", a_counters_enabled ? "Enabled" : "Disabled");
640   anna::xml::Node* registeredCounterScopes = result->createChild("RegisteredCounterScopes");
641
642   for(const_scope_iterator scope_it = scope_begin(); scope_it != scope_end(); scope_it++) {
643     // Scope:
644     anna::xml::Node* scopeNode = registeredCounterScopes->createChild("Scope");
645     int scopeId = (*scope_it).first;
646     scopeNode->createAttribute("Id", anna::functions::asString(scopeId));
647     scopeNode->createAttribute("Description", scope(scope_it)->getName());
648     // Counters:
649     anna::xml::Node* registeredCounters = scopeNode->createChild("RegisteredCounters");
650     counter_data_t * ptrCounterData;
651
652     for(const_counter_iterator cnt_it = counter_begin(); cnt_it != counter_end(); cnt_it++) {
653       ptrCounterData = (counter_data_t *) & ((*cnt_it).second);
654       // Counter:
655       anna::xml::Node* counter = registeredCounters->createChild("Counter");
656       counter->createAttribute("Type", anna::functions::asString((*cnt_it).first));
657       counter->createAttribute("Description", ptrCounterData->Description);
658       int offset = ptrCounterData->Offset;
659       int realId = (1000 * scopeId) + offset;
660       counter->createAttribute("ScopeId", anna::functions::asString(scopeId));
661       counter->createAttribute("Offset", anna::functions::asString(offset));
662       counter->createAttribute("RealId", anna::functions::asString(realId));
663       unsigned long long int accValue = scope(scope_it)->getAccValue(offset);
664
665       if(accValue != 0ULL)
666         counter->createAttribute("AccumulatedAmount", anna::functions::asString("%llu", accValue));
667     }
668   }
669
670   result->createAttribute("Alarms", a_alarms_enabled ? "Enabled" : "Disabled");
671   result->createAttribute("PreffixAlarmComponents", a_alarms_preffix_enabled ? "Shown" : "Hidden");
672   result->createAttribute("SuffixAlarmComponents", a_alarms_suffix_enabled ? "Shown" : "Hidden");
673   anna::xml::Node* registeredAlarms = result->createChild("RegisteredAlarms");
674
675   for(const_alarm_iterator alrm_it = alarm_begin(); alrm_it != alarm_end(); alrm_it++) {
676     anna::xml::Node* alarm;
677     int cancellationId = (*alrm_it).second.CancellationId;
678     bool transferable = (cancellationId != -1);
679     alarm  = registeredAlarms->createChild("Alarm");
680     alarm->createAttribute("Type", anna::functions::asString((*alrm_it).first));
681     std::string desc = (*alrm_it).second.Description; desc += " ["; desc += transferable ? "transferable]" : "non transferable]";
682     alarm->createAttribute("Description", desc);
683     alarm->createAttribute("DatabaseId", anna::functions::asString((*alrm_it).second.ExternalId));
684     alarm->createAttribute("DynamicVariablesCSL", (*alrm_it).second.DynamicVariablesCSL);
685     alarm->createAttribute("ActivationId", anna::functions::asString((*alrm_it).second.ActivationId));
686
687     if(transferable) alarm->createAttribute("CancellationId", anna::functions::asString(cancellationId));
688   }
689
690   return result;
691 }
692