SST  6.1.0
StructuralSimulationToolkit
sstinfo.h
1 // Copyright 2009-2016 Sandia Corporation. Under the terms
2 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
3 // Government retains certain rights in this software.
4 //
5 // Copyright (c) 2009-2016, Sandia Corporation
6 // All rights reserved.
7 //
8 // This file is part of the SST software package. For license
9 // information, see the LICENSE file in the top level directory of the
10 // distribution.
11 
12 
13 #ifndef SST_INFO_H
14 #define SST_INFO_H
15 
16 namespace SST {
17 
18 // CONFIGURATION BITS
19 #define CFG_OUTPUTHUMAN 0x00000001
20 #define CFG_OUTPUTXML 0x00000002
21 
22 /**
23  * The SSTInfo Configuration class.
24  *
25  * This class will parse the command line, and setup internal
26  * lists of elements and components to be processed.
27  */
29 public:
30  /** Create a new SSTInfo configuration and parse the Command Line. */
31  SSTInfoConfig();
32  ~SSTInfoConfig();
33 
34  /** Parse the Command Line.
35  * @param argc The number of arguments passed to the application
36  * @param argv The array of arguments
37  */
38  int parseCmdLine(int argc, char* argv[]);
39 
40  /** Return the list of elements to be processed. */
41  std::vector<std::string>* getElementsToProcessArray() {return &m_elementsToProcess;}
42 
43  /** Return the list of filtered element names. */
44  std::vector<std::string>* getFilteredElementNamesArray() {return &m_filteredElementNames;}
45 
46  /** Return the list of filtered element.component names. */
47  std::vector<std::string>* getFilteredElementComponentNamesArray() {return &m_filteredElementComponentNames;}
48 
49  /** Return the bit field of various command line options enabled. */
50  unsigned int getOptionBits() {return m_optionBits;}
51 
52  /** Return the user defined path the XML File. */
53  std::string& getXMLFilePath() {return m_XMLFilePath;}
54 
55  /** Is debugging output enabled? */
56  bool debugEnabled() const { return m_debugEnabled; }
57 
58 private:
59  void outputUsage();
60  void outputVersion();
61 
62 private:
63  char* m_AppName;
64  std::vector<std::string> m_elementsToProcess;
65  std::vector<std::string> m_filteredElementNames;
66  std::vector<std::string> m_filteredElementComponentNames;
67  unsigned int m_optionBits;
68  std::string m_XMLFilePath;
69  bool m_debugEnabled;
70 };
71 
72 /**
73  * The SSTInfo representation of ElementInfoParam object.
74  *
75  * This class is used internally by SSTInfo to load and process
76  * ElementInfoParam objects.
77  */
79 public:
80  /** Create a new SSTInfoElement_ParamInfo object.
81  * @param elparam Pointer to an ElementInfoParam object.
82  */
84  {
85  // Save the Object
86  m_elparam = elparam;
87  }
88 
89  /** Return the Name of the Parameter. */
90  const char* getName() {return m_elparam->name;}
91 
92  /** Return the Description of the Parameter. */
93  const char* getDesc() {return m_elparam->description;}
94 
95  /** Return the Default value of the Parameter. */
96  const char* getDefault() {return (m_elparam->defaultValue) ? m_elparam->defaultValue : "REQUIRED";}
97 
98  /** Output the Parameter Information.
99  * @param Index The Index of the Parameter.
100  */
101  void outputParameterInfo(int Index);
102 
103  /** Create the formatted XML data of the Parameter.
104  * @param Index The Index of the Parameter.
105  * @param XMLParentElement The parent element to receive the XML data.
106  */
107  void generateParameterInfoXMLData(int Index, TiXmlNode* XMLParentElement);
108 
109 private:
110  const ElementInfoParam* m_elparam;
111 };
112 
113 void PopulateParams(const ElementInfoParam* ptrParams, std::vector<SSTInfoElement_ParamInfo*>* ptrParamArray)
114 {
115  // Populate the Parameter Array
116  if (NULL != ptrParams) {
117  while (NULL != ptrParams->name) {
118  // Create a new SSTInfoElement_ParamInfo and add it to the m_ParamArray
119  SSTInfoElement_ParamInfo* ptrParamInfo = new SSTInfoElement_ParamInfo(ptrParams);
120  ptrParamArray->push_back(ptrParamInfo);
121 
122  // If the name is NULL, we have reached the last item
123  ptrParams++; // Get the next structure item
124  }
125  }
126 }
127 
128 /**
129  * The SSTInfo representation of ElementInfoPort object.
130  *
131  * This class is used internally by SSTInfo to load and process
132  * ElementInfoPort objects.
133  */
135 public:
136  /** Create a new SSTInfoElement_PortInfo object.
137  * @param elport Pointer to an ElementInfoPort object.
138  */
140  {
141  // Save the Object
142  m_numValidEvents = 0;
143  m_elport = elport;
144 
145  analyzeValidEventsArray();
146  }
147 
148  /** Return the Name of the Port. */
149  const char* getName() {return m_elport->name;}
150 
151  /** Return the Description of the Port. */
152  const char* getDesc() {return m_elport->description;}
153 
154  /** Return the array of Valid Events related to the Port. */
155  const char** getValidEvents() {return m_elport->validEvents;}
156 
157  /** Return the number of Valid Events related to the Port. */
158  int getNumberOfValidEvents() {return m_numValidEvents;}
159 
160  /** Return the a specific Valid Events.
161  * @param index The index of the Valid Event.
162  */
163  const char* getValidEvent(unsigned int index);
164 
165  /** Output the Port Information.
166  * @param Index The Index of the Port.
167  */
168  void outputPortInfo(int Index);
169 
170  /** Create the formatted XML data of the Port.
171  * @param Index The Index of the Port.
172  * @param XMLParentElement The parent element to receive the XML data.
173  */
174  void generatePortInfoXMLData(int Index, TiXmlNode* XMLParentElement);
175 
176 private:
177  void analyzeValidEventsArray();
178 
179  const ElementInfoPort* m_elport;
180  unsigned int m_numValidEvents;
181 };
182 
183 void PopulatePorts(const ElementInfoPort* ptrPorts, std::vector<SSTInfoElement_PortInfo*>* ptrPortArray)
184 {
185  // Populate the Ports Array
186  if (NULL != ptrPorts) {
187  while (NULL != ptrPorts->name) {
188  // Create a new SSTInfoElement_PortInfo and add it to the m_PortArray
189  SSTInfoElement_PortInfo* ptrPortInfo = new SSTInfoElement_PortInfo(ptrPorts);
190  ptrPortArray->push_back(ptrPortInfo);
191 
192  // If the name is NULL, we have reached the last item
193  ptrPorts++; // Get the next structure item
194  }
195  }
196 }
197 
198 /**
199  * The SSTInfo representation of ElementInfoPort object.
200  *
201  * This class is used internally by SSTInfo to load and process
202  * ElementInfoPort objects.
203  */
205 public:
206  /** Create a new SSTInfoElement_StatisticInfo object.
207  * @param elstat Pointer to an ElementInfoStatistic object.
208  */
210  {
211  // Save the Object
212  m_elstat = elstat;
213  }
214 
215  /** Return the Name of the Statistic. */
216  const char* getName() {return m_elstat->name;}
217 
218  /** Return the Description of the Statistic. */
219  const char* getDesc() {return m_elstat->description;}
220 
221  /** Return the Units of the Statistic. */
222  const char* getUnits() {return m_elstat->units;}
223 
224  /** Return the enable level of the Statistic. */
225  const uint8_t getEnableLevel() {return m_elstat->enableLevel;}
226 
227  /** Output the Statistic Information.
228  * @param Index The Index of the Statistic.
229  */
230  void outputStatisticInfo(int Index);
231 
232  /** Create the formatted XML data of the Statistic.
233  * @param Index The Index of the Statistic.
234  * @param XMLParentElement The parent element to receive the XML data.
235  */
236  void generateStatisticXMLData(int Index, TiXmlNode* XMLParentElement);
237 
238 private:
239  const ElementInfoStatistic* m_elstat;
240 };
241 
242 void PopulateStatistic(const ElementInfoStatistic* ptrStats, std::vector<SSTInfoElement_StatisticInfo*>* ptrStatArray)
243 {
244  // Populate the Statistics Array
245  if (NULL != ptrStats) {
246  while (NULL != ptrStats->name) {
247  // Create a new SSTInfoElement_Statistic and add it to the m_StatisticArray
248  SSTInfoElement_StatisticInfo* ptrStatInfo = new SSTInfoElement_StatisticInfo(ptrStats);
249  ptrStatArray->push_back(ptrStatInfo);
250 
251  // If the name is NULL, we have reached the last item
252  ptrStats++; // Get the next structure item
253  }
254  }
255 }
256 
257 /**
258  * The SSTInfo representation of ElementInfoComponent object.
259  *
260  * This class is used internally by SSTInfo to load and process
261  * ElementInfoComponent objects.
262  */
264 public:
265  /** Create a new SSTInfoElement_ComponentInfo object.
266  * @param elc Pointer to an ElementInfoComponent object.
267  */
269  {
270  const ElementInfoParam* ptrParams;
271  const ElementInfoPort* ptrPorts;
272  const ElementInfoStatistic* ptrStats;
273 
274  // Save the Object
275  m_elc = elc;
276 
277  ptrParams = elc->params; // Pointer to the Params Structure Array
278  PopulateParams(ptrParams, &m_ParamArray);
279 
280  ptrPorts = elc->ports; // Pointer to the Ports Structure Array
281  PopulatePorts(ptrPorts, &m_PortArray);
282 
283  buildCategoryString();
284 
285  ptrStats = elc->stats; // Pointer to the Stats Structure Array
286  PopulateStatistic(ptrStats, &m_StatisticArray);
287  }
288 
289  /** Return the Name of the Component. */
290  const char* getName() {return m_elc->name;}
291 
292  /** Return the Description of the Component. */
293  const char* getDesc() {return m_elc->description;}
294 
295  /** Return a Parameter Info Object.
296  * @param index The index of the Parameter.
297  */
298  SSTInfoElement_ParamInfo* getParamInfo(int index) {return m_ParamArray[index];}
299 
300  /** Return a Port Info Object.
301  * @param index The index of the Port.
302  */
303  SSTInfoElement_PortInfo* getPortInfo(int index) {return m_PortArray[index];}
304 
305  /** Return a Statistic Enable Info Object.
306  * @param index The index of the Statistic Enable.
307  */
308  SSTInfoElement_StatisticInfo* getStatisticInfo(int index) {return m_StatisticArray[index];}
309 
310  /** Return the Category value of the Component. */
311  uint32_t getCategoryValue() {return m_elc->category;}
312 
313  /** Return the name of the Category of the Component. */
314  const char* getCategoryString() {return m_CategoryString.c_str();}
315 
316  /** Output the Component Information.
317  * @param Index The Index of the Component.
318  */
319  void outputComponentInfo(int Index);
320 
321  /** Create the formatted XML data of the Component.
322  * @param Index The Index of the Component.
323  * @param XMLParentElement The parent element to receive the XML data.
324  */
325  void generateComponentInfoXMLData(int Index, TiXmlNode* XMLParentElement);
326 
327 private:
328  void buildCategoryString();
329 
330  const ElementInfoComponent* m_elc;
331  std::vector<SSTInfoElement_ParamInfo*> m_ParamArray;
332  std::vector<SSTInfoElement_PortInfo*> m_PortArray;
333  std::vector<SSTInfoElement_StatisticInfo*> m_StatisticArray;
334  std::string m_CategoryString;
335 };
336 
337 /**
338  * The SSTInfo representation of ElementInfoIntrospector object.
339  *
340  * This class is used internally by SSTInfo to load and process
341  * ElementInfoIntrospector objects.
342  */
344 public:
345  /** Create a new SSTInfoElement_IntrospectorInfo object.
346  * @param eli Pointer to an ElementInfoIntrospector object.
347  */
349  {
350  const ElementInfoParam* ptrParams;
351 
352  // Save the Object
353  m_eli = eli;
354 
355  ptrParams = eli->params; // Pointer to the Params Structure Array
356  PopulateParams(ptrParams, &m_ParamArray);
357  }
358 
359  /** Return the Name of the Introspector. */
360  const char* getName() {return m_eli->name;}
361 
362  /** Return the Description of the Introspector. */
363  const char* getDesc() {return m_eli->description;}
364 
365  /** Return a Parameter Info Object.
366  * @param index The index of the Parameter.
367  */
368  SSTInfoElement_ParamInfo* getParamInfo(int index) {return m_ParamArray[index];}
369 
370  /** Output the Introspector Information.
371  * @param Index The Index of the Introspector.
372  */
373  void outputIntrospectorInfo(int Index);
374 
375  /** Create the formatted XML data of the Introspector.
376  * @param Index The Index of the Introspector.
377  * @param XMLParentElement The parent element to receive the XML data.
378  */
379  void generateIntrospectorInfoXMLData(int Index, TiXmlNode* XMLParentElement);
380 
381 private:
382  const ElementInfoIntrospector* m_eli;
383  std::vector<SSTInfoElement_ParamInfo*> m_ParamArray;
384 };
385 
386 /**
387  * The SSTInfo representation of ElementInfoEvent object.
388  *
389  * This class is used internally by SSTInfo to load and process
390  * ElementInfoEvent objects.
391  */
393 public:
394  /** Create a new SSTInfoElement_EventInfo object.
395  * @param ele Pointer to an ElementInfoEvent object.
396  */
398  {
399  // Save the Object
400  m_ele = ele;
401  }
402 
403  /** Return the Name of the Event. */
404  const char* getName() {return m_ele->name;}
405 
406  /** Return the Description of the Event. */
407  const char* getDesc() {return m_ele->description;}
408 
409  /** Output the Event Information.
410  * @param Index The Index of the Event.
411  */
412  void outputEventInfo(int Index);
413 
414  /** Create the formatted XML data of the Event.
415  * @param Index The Index of the Event.
416  * @param XMLParentElement The parent element to receive the XML data.
417  */
418  void generateEventInfoXMLData(int Index, TiXmlNode* XMLParentElement);
419 
420 private:
421  const ElementInfoEvent* m_ele;
422 };
423 
424 /**
425  * The SSTInfo representation of ElementInfoModule object.
426  *
427  * This class is used internally by SSTInfo to load and process
428  * ElementInfoModule objects.
429  */
431 public:
432  /** Create a new SSTInfoElement_ModuleInfo object.
433  * @param elm Pointer to an ElementInfoModule object.
434  */
436  {
437  const ElementInfoParam* ptrParams;
438 
439  // Save the Object
440  m_elm = elm;
441 
442  ptrParams = elm->params; // Pointer to the Params Structure Array
443  PopulateParams(ptrParams, &m_ParamArray);
444  }
445 
446  /** Return the Name of the Module. */
447  const char* getName() {return m_elm->name;}
448 
449  /** Return the Description of the Module. */
450  const char* getDesc() {return m_elm->description;}
451 
452  /** Return what class the Module provides. */
453  const char* getProvides() { return m_elm->provides;}
454 
455  /** Return a Parameter Info Object.
456  * @param index The index of the Parameter.
457  */
458  SSTInfoElement_ParamInfo* getParamInfo(int index) {return m_ParamArray[index];}
459 
460  /** Output the Module Information.
461  * @param Index The Index of the Module.
462  */
463  void outputModuleInfo(int Index);
464 
465  /** Create the formatted XML data of the Module.
466  * @param Index The Index of the Module.
467  * @param XMLParentElement The parent element to receive the XML data.
468  */
469  void generateModuleInfoXMLData(int Index, TiXmlNode* XMLParentElement);
470 
471 private:
472  const ElementInfoModule* m_elm;
473  std::vector<SSTInfoElement_ParamInfo*> m_ParamArray;
474 };
475 
476 /**
477  * The SSTInfo representation of ElementInfoSubComponent object.
478  *
479  * This class is used internally by SSTInfo to load and process
480  * ElementInfoSubComponent objects.
481  */
483 public:
484  /** Create a new SSTInfoElement_SubComponentInfo object.
485  * @param elsc Pointer to an ElementInfoComponent object.
486  */
488  {
489  const ElementInfoParam* ptrParams;
490  const ElementInfoStatistic* ptrStats;
491 
492  // Save the Object
493  m_elsc = elsc;
494 
495  ptrParams = elsc->params; // Pointer to the Params Structure Array
496  PopulateParams(ptrParams, &m_ParamArray);
497 
498  ptrStats = elsc->stats; // Pointer to the Stats Structure Array
499  PopulateStatistic(ptrStats, &m_StatisticArray);
500  }
501 
502  /** Return the Name of the SubComponent. */
503  const char* getName() {return m_elsc->name;}
504 
505  /** Return the Description of the SubComponent. */
506  const char* getDesc() {return m_elsc->description;}
507 
508  /** Return a Parameter Info Object.
509  * @param index The index of the Parameter.
510  */
511  SSTInfoElement_ParamInfo* getParamInfo(int index) {return m_ParamArray[index];}
512 
513  /** Return a Statistic Enable Info Object.
514  * @param index The index of the Statistic Enable.
515  */
516  SSTInfoElement_StatisticInfo* getStatisticInfo(int index) {return m_StatisticArray[index];}
517 
518  /** Output the SubComponent Information.
519  * @param Index The Index of the SubComponent.
520  */
521  void outputSubComponentInfo(int Index);
522 
523  /** Create the formatted XML data of the Component.
524  * @param Index The Index of the Component.
525  * @param XMLParentElement The parent element to receive the XML data.
526  */
527  void generateSubComponentInfoXMLData(int Index, TiXmlNode* XMLParentElement);
528 
529 private:
530  const ElementInfoSubComponent* m_elsc;
531  std::vector<SSTInfoElement_ParamInfo*> m_ParamArray;
532  std::vector<SSTInfoElement_StatisticInfo*> m_StatisticArray;
533 };
534 
535 /**
536  * The SSTInfo representation of ElementInfoPartitioner object.
537  *
538  * This class is used internally by SSTInfo to load and process
539  * ElementInfoPartitioner objects.
540  */
542 public:
543  /** Create a new SSTInfoElement_PartitionerInfo object.
544  * @param elp Pointer to an ElementInfoPartitioner object.
545  */
547  {
548  // Save the Object
549  m_elp = elp;
550  }
551 
552  /** Return the Name of the Partitioner. */
553  const char* getName() {return m_elp->name;}
554 
555  /** Return the Description of the Partitioner. */
556  const char* getDesc() {return m_elp->description;}
557 
558  /** Output the Partitioner Information.
559  * @param Index The Index of the Partitioner.
560  */
561  void outputPartitionerInfo(int Index);
562 
563  /** Create the formatted XML data of the Partitioner.
564  * @param Index The Index of the Partitioner.
565  * @param XMLParentElement The parent element to receive the XML data.
566  */
567  void generatePartitionerInfoXMLData(int Index, TiXmlNode* XMLParentElement);
568 
569 private:
570  const ElementInfoPartitioner* m_elp;
571 };
572 
573 /**
574  * The SSTInfo representation of ElementInfoGenerator object.
575  *
576  * This class is used internally by SSTInfo to load and process
577  * ElementInfoGenerator objects.
578  */
580 public:
581  /** Create a new SSTInfoElement_GeneratorInfo object.
582  * @param elg Pointer to an ElementInfoGenerator object.
583  */
585  {
586  // Save the Object
587  m_elg = elg;
588  }
589 
590  /** Return the Name of the Generator. */
591  const char* getName() {return m_elg->name;}
592 
593  /** Return the Description of the Generator. */
594  const char* getDesc() {return m_elg->description;}
595 
596  /** Output the Generator Information.
597  * @param Index The Index of the Generator.
598  */
599  void outputGeneratorInfo(int Index);
600 
601  /** Create the formatted XML data of the Generator.
602  * @param Index The Index of the Generator.
603  * @param XMLParentElement The parent element to receive the XML data.
604  */
605  void generateGeneratorInfoXMLData(int Index, TiXmlNode* XMLParentElement);
606 
607 private:
608  const ElementInfoGenerator* m_elg;
609 };
610 
611 
612 /**
613  * The SSTInfo representation of ElementLibraryInfo object.
614  *
615  * This class is used internally by SSTInfo to load and process
616  * ElementLibraryInfo objects.
617  */
619 
620 public:
621  /** Create a new SSTInfoElement_LibraryInfo object.
622  * @param eli Pointer to an ElementLibraryInfo object.
623  */
625  {
626  m_eli = eli;
627  populateLibraryInfo();
628  }
629 
630  /** Return the Name of the Library. */
631  std::string getLibraryName() {if (m_eli && m_eli->name) return m_eli->name; else return ""; }
632 
633  /** Return the Description of the Library. */
634  std::string getLibraryDescription() {if (m_eli && m_eli->description) return m_eli->description; else return ""; }
635 
636  /** Return the number of Components within the Library. */
637  int getNumberOfLibraryComponents() {return m_ComponentArray.size();}
638 
639  /** Return the number of Introspectors within the Library. */
640  int getNumberOfLibraryIntrospectors() {return m_IntrospectorArray.size();}
641 
642  /** Return the number of Events within the Library. */
643  int getNumberOfLibraryEvents() {return m_EventArray.size();}
644 
645  /** Return the number of Modules within the Library. */
646  int getNumberOfLibraryModules() {return m_ModuleArray.size();}
647 
648  /** Return the number of SubComponents within the Library. */
649  int getNumberOfLibrarySubComponents() {return m_SubComponentArray.size();}
650 
651  /** Return the number of Partitioners within the Library. */
652  int getNumberOfLibraryPartitioners() {return m_PartitionerArray.size();}
653 
654  /** Return the number of Generators within the Library. */
655  int getNumberOfLibraryGenerators() {return m_GeneratorArray.size();}
656 
657  /** Return the ElementLibraryInfo object. */
658  const ElementLibraryInfo* getLibraryInfo() {return m_eli;}
659 
660  /** Return a specific SSTInfoElement_ComponentInfo object.
661  * @param Index The index of the object.
662  */
663  SSTInfoElement_ComponentInfo* getInfoComponent(int Index) {return m_ComponentArray[Index];}
664 
665  /** Return a specific SSTInfoElement_IntrospectorInfo object.
666  * @param Index The index of the object.
667  */
668  SSTInfoElement_IntrospectorInfo* getInfoIntrospector(int Index) {return m_IntrospectorArray[Index];}
669 
670  /** Return a specific SSTInfoElement_EventInfo object.
671  * @param Index The index of the object.
672  */
673  SSTInfoElement_EventInfo* getInfoEvent(int Index) {return m_EventArray[Index];}
674 
675  /** Return a specific SSTInfoElement_ModuleInfo object.
676  * @param Index The index of the object.
677  */
678  SSTInfoElement_ModuleInfo* getInfoModule(int Index) {return m_ModuleArray[Index];}
679 
680  /** Return a specific SSTInfoElement_SubComponentInfo object.
681  * @param Index The index of the object.
682  */
683  SSTInfoElement_SubComponentInfo* getInfoSubComponent(int Index) {return m_SubComponentArray[Index];}
684 
685  /** Return a specific SSTInfoElement_PartitionerInfo object.
686  * @param Index The index of the object.
687  */
688  SSTInfoElement_PartitionerInfo* getInfoPartitioner(int Index) {return m_PartitionerArray[Index];}
689 
690  /** Return a specific SSTInfoElement_GeneratorInfo object.
691  * @param Index The index of the object.
692  */
693  SSTInfoElement_GeneratorInfo* getInfoGenerator(int Index) {return m_GeneratorArray[Index];}
694 
695  /** Output the Library Information.
696  * @param LibIndex The Index of the Library.
697  */
698  void outputLibraryInfo(int LibIndex);
699 
700  /** Create the formatted XML data of the Library.
701  * @param LibIndex The Index of the Library.
702  * @param XMLParentElement The parent element to receive the XML data.
703  */
704  void generateLibraryInfoXMLData(int LibIndex, TiXmlNode* XMLParentElement);
705 
706 private:
707  void populateLibraryInfo();
708  void addInfoComponent(const ElementInfoComponent* eic) {m_ComponentArray.push_back(new SSTInfoElement_ComponentInfo(eic));}
709  void addInfoIntrospector(const ElementInfoIntrospector* eii) {m_IntrospectorArray.push_back(new SSTInfoElement_IntrospectorInfo(eii));}
710  void addInfoEvent(const ElementInfoEvent* eie) {m_EventArray.push_back(new SSTInfoElement_EventInfo(eie));}
711  void addInfoModule(const ElementInfoModule* eim) {m_ModuleArray.push_back(new SSTInfoElement_ModuleInfo(eim));}
712  void addInfoSubComponent(const ElementInfoSubComponent* eisc) {m_SubComponentArray.push_back(new SSTInfoElement_SubComponentInfo(eisc));}
713  void addInfoPartitioner(const ElementInfoPartitioner* eip) {m_PartitionerArray.push_back(new SSTInfoElement_PartitionerInfo(eip));}
714  void addInfoGenerator(const ElementInfoGenerator* eig) {m_GeneratorArray.push_back(new SSTInfoElement_GeneratorInfo(eig));}
715 
716  const ElementLibraryInfo* m_eli;
717  std::vector<SSTInfoElement_ComponentInfo*> m_ComponentArray;
718  std::vector<SSTInfoElement_IntrospectorInfo*> m_IntrospectorArray;
719  std::vector<SSTInfoElement_EventInfo*> m_EventArray;
720  std::vector<SSTInfoElement_ModuleInfo*> m_ModuleArray;
721  std::vector<SSTInfoElement_SubComponentInfo*> m_SubComponentArray;
722  std::vector<SSTInfoElement_PartitionerInfo*> m_PartitionerArray;
723  std::vector<SSTInfoElement_GeneratorInfo*> m_GeneratorArray;
724 
725 };
726 
727 } // namespace SST
728 
729 #endif // SST_INFO_H
SSTInfoElement_GeneratorInfo * getInfoGenerator(int Index)
Return a specific SSTInfoElement_GeneratorInfo object.
Definition: sstinfo.h:693
SSTInfoElement_PartitionerInfo(const ElementInfoPartitioner *elp)
Create a new SSTInfoElement_PartitionerInfo object.
Definition: sstinfo.h:546
const ElementInfoStatistic * stats
Definition: element.h:128
void outputPortInfo(int Index)
Output the Port Information.
Definition: sstinfo.cc:868
SSTInfoElement_ModuleInfo * getInfoModule(int Index)
Return a specific SSTInfoElement_ModuleInfo object.
Definition: sstinfo.h:678
const char * getDesc()
Return the Description of the Event.
Definition: sstinfo.h:407
Describes an Event.
Definition: element.h:103
const char * getName()
Return the Name of the Port.
Definition: sstinfo.h:149
void outputPartitionerInfo(int Index)
Output the Partitioner Information.
Definition: sstinfo.cc:1206
int getNumberOfLibraryComponents()
Return the number of Components within the Library.
Definition: sstinfo.h:637
SSTInfoElement_PartitionerInfo * getInfoPartitioner(int Index)
Return a specific SSTInfoElement_PartitionerInfo object.
Definition: sstinfo.h:688
const char * provides
Definition: element.h:119
Describes a Component and its associated information.
Definition: element.h:80
The SSTInfo representation of ElementLibraryInfo object.
Definition: sstinfo.h:618
Describes a Partitioner.
Definition: element.h:134
const char * getDesc()
Return the Description of the Port.
Definition: sstinfo.h:152
const uint8_t getEnableLevel()
Return the enable level of the Statistic.
Definition: sstinfo.h:225
SSTInfoElement_EventInfo * getInfoEvent(int Index)
Return a specific SSTInfoElement_EventInfo object.
Definition: sstinfo.h:673
const char * getName()
Return the Name of the Component.
Definition: sstinfo.h:290
const char * description
Definition: element.h:82
const char * getDesc()
Return the Description of the Parameter.
Definition: sstinfo.h:93
std::vector< std::string > * getElementsToProcessArray()
Return the list of elements to be processed.
Definition: sstinfo.h:41
const char * defaultValue
Definition: element.h:67
void generateParameterInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Parameter.
Definition: sstinfo.cc:855
std::string getLibraryDescription()
Return the Description of the Library.
Definition: sstinfo.h:634
const char * description
Definition: element.h:66
The SSTInfo representation of ElementInfoIntrospector object.
Definition: sstinfo.h:343
const char * getName()
Return the Name of the Statistic.
Definition: sstinfo.h:216
The SSTInfo representation of ElementInfoGenerator object.
Definition: sstinfo.h:579
const char ** validEvents
Definition: element.h:75
const char * getDesc()
Return the Description of the Partitioner.
Definition: sstinfo.h:556
The SSTInfo representation of ElementInfoModule object.
Definition: sstinfo.h:430
SSTInfoElement_IntrospectorInfo(const ElementInfoIntrospector *eli)
Create a new SSTInfoElement_IntrospectorInfo object.
Definition: sstinfo.h:348
uint32_t category
Definition: element.h:87
const char * getName()
Return the Name of the Module.
Definition: sstinfo.h:447
const char * name
Definition: element.h:81
Describes all the parts of the Element Library.
Definition: element.h:152
int getNumberOfLibrarySubComponents()
Return the number of SubComponents within the Library.
Definition: sstinfo.h:649
The SSTInfo representation of ElementInfoEvent object.
Definition: sstinfo.h:392
SSTInfoElement_PortInfo * getPortInfo(int index)
Return a Port Info Object.
Definition: sstinfo.h:303
SSTInfoElement_ParamInfo * getParamInfo(int index)
Return a Parameter Info Object.
Definition: sstinfo.h:368
const char * getName()
Return the Name of the Introspector.
Definition: sstinfo.h:360
SSTInfoElement_SubComponentInfo * getInfoSubComponent(int Index)
Return a specific SSTInfoElement_SubComponentInfo object.
Definition: sstinfo.h:683
const char * getName()
Return the Name of the Generator.
Definition: sstinfo.h:591
void generateSubComponentInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Component.
Definition: sstinfo.cc:1174
const char * description
Definition: element.h:95
SSTInfoElement_ParamInfo(const ElementInfoParam *elparam)
Create a new SSTInfoElement_ParamInfo object.
Definition: sstinfo.h:83
const char * description
Definition: element.h:105
The SSTInfo representation of ElementInfoComponent object.
Definition: sstinfo.h:263
void generateStatisticXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Statistic.
Definition: sstinfo.cc:952
SSTInfoElement_ModuleInfo(const ElementInfoModule *elm)
Create a new SSTInfoElement_ModuleInfo object.
Definition: sstinfo.h:435
Definition: action.cc:17
const char * name
Definition: element.h:153
const char ** getValidEvents()
Return the array of Valid Events related to the Port.
Definition: sstinfo.h:155
const char * getDefault()
Return the Default value of the Parameter.
Definition: sstinfo.h:96
SSTInfoElement_IntrospectorInfo * getInfoIntrospector(int Index)
Return a specific SSTInfoElement_IntrospectorInfo object.
Definition: sstinfo.h:668
const char * getDesc()
Return the Description of the Generator.
Definition: sstinfo.h:594
SSTInfoElement_ComponentInfo * getInfoComponent(int Index)
Return a specific SSTInfoElement_ComponentInfo object.
Definition: sstinfo.h:663
void generateGeneratorInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Generator.
Definition: sstinfo.cc:1228
const char * getName()
Return the Name of the Parameter.
Definition: sstinfo.h:90
const ElementInfoStatistic * stats
Definition: element.h:88
SSTInfoElement_GeneratorInfo(const ElementInfoGenerator *elg)
Create a new SSTInfoElement_GeneratorInfo object.
Definition: sstinfo.h:584
const char * getName()
Return the Name of the SubComponent.
Definition: sstinfo.h:503
SSTInfoElement_SubComponentInfo(const ElementInfoSubComponent *elsc)
Create a new SSTInfoElement_SubComponentInfo object.
Definition: sstinfo.h:487
SSTInfoElement_StatisticInfo(const ElementInfoStatistic *elstat)
Create a new SSTInfoElement_StatisticInfo object.
Definition: sstinfo.h:209
void generatePortInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Port.
Definition: sstinfo.cc:878
std::vector< std::string > * getFilteredElementComponentNamesArray()
Return the list of filtered element.component names.
Definition: sstinfo.h:47
const char * getProvides()
Return what class the Module provides.
Definition: sstinfo.h:453
SSTInfoElement_StatisticInfo * getStatisticInfo(int index)
Return a Statistic Enable Info Object.
Definition: sstinfo.h:308
void outputComponentInfo(int Index)
Output the Component Information.
Definition: sstinfo.cc:968
const char * getDesc()
Return the Description of the Statistic.
Definition: sstinfo.h:219
const char * getDesc()
Return the Description of the SubComponent.
Definition: sstinfo.h:506
std::vector< std::string > * getFilteredElementNamesArray()
Return the list of filtered element names.
Definition: sstinfo.h:44
The SSTInfo Configuration class.
Definition: sstinfo.h:28
Describes Statistics used by a Component.
Definition: element.h:55
int getNumberOfLibraryGenerators()
Return the number of Generators within the Library.
Definition: sstinfo.h:655
void outputIntrospectorInfo(int Index)
Output the Introspector Information.
Definition: sstinfo.cc:1070
Describes a Generator.
Definition: element.h:143
const char * getName()
Return the Name of the Event.
Definition: sstinfo.h:404
const char * name
Definition: element.h:104
Describes an Introspector.
Definition: element.h:93
void generateModuleInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Module.
Definition: sstinfo.cc:1132
void outputStatisticInfo(int Index)
Output the Statistic Information.
Definition: sstinfo.cc:947
void outputModuleInfo(int Index)
Output the Module Information.
Definition: sstinfo.cc:1121
The SSTInfo representation of ElementInfoParam object.
Definition: sstinfo.h:78
const char * description
Definition: element.h:74
void generateEventInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Event.
Definition: sstinfo.cc:1109
void outputParameterInfo(int Index)
Output the Parameter Information.
Definition: sstinfo.cc:850
void outputLibraryInfo(int LibIndex)
Output the Library Information.
Definition: sstinfo.cc:642
const char * description
Definition: element.h:136
const char * getDesc()
Return the Description of the Module.
Definition: sstinfo.h:450
void generatePartitionerInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Partitioner.
Definition: sstinfo.cc:1211
const char * name
Definition: element.h:65
SSTInfoElement_StatisticInfo * getStatisticInfo(int index)
Return a Statistic Enable Info Object.
Definition: sstinfo.h:516
The SSTInfo representation of ElementInfoPort object.
Definition: sstinfo.h:134
const ElementInfoParam * params
Definition: element.h:98
void generateComponentInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Component.
Definition: sstinfo.cc:992
bool debugEnabled() const
Is debugging output enabled?
Definition: sstinfo.h:56
std::string & getXMLFilePath()
Return the user defined path the XML File.
Definition: sstinfo.h:53
const char * name
Definition: element.h:94
const char * getName()
Return the Name of the Partitioner.
Definition: sstinfo.h:553
const ElementLibraryInfo * getLibraryInfo()
Return the ElementLibraryInfo object.
Definition: sstinfo.h:658
SSTInfoConfig()
Create a new SSTInfo configuration and parse the Command Line.
Definition: sstinfo.cc:404
SSTInfoElement_LibraryInfo(const ElementLibraryInfo *eli)
Create a new SSTInfoElement_LibraryInfo object.
Definition: sstinfo.h:624
const char * name
Definition: element.h:56
int getNumberOfLibraryIntrospectors()
Return the number of Introspectors within the Library.
Definition: sstinfo.h:640
SSTInfoElement_EventInfo(const ElementInfoEvent *ele)
Create a new SSTInfoElement_EventInfo object.
Definition: sstinfo.h:397
const char * getDesc()
Return the Description of the Introspector.
Definition: sstinfo.h:363
const ElementInfoParam * params
Definition: element.h:127
Describes Parameters to a Component.
Definition: element.h:64
int getNumberOfLibraryEvents()
Return the number of Events within the Library.
Definition: sstinfo.h:643
void outputEventInfo(int Index)
Output the Event Information.
Definition: sstinfo.cc:1104
const char * description
Definition: element.h:114
const char * description
Definition: element.h:57
int getNumberOfValidEvents()
Return the number of Valid Events related to the Port.
Definition: sstinfo.h:158
int getNumberOfLibraryModules()
Return the number of Modules within the Library.
Definition: sstinfo.h:646
int parseCmdLine(int argc, char *argv[])
Parse the Command Line.
Definition: sstinfo.cc:433
void generateIntrospectorInfoXMLData(int Index, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Introspector.
Definition: sstinfo.cc:1081
const char * name
Definition: element.h:113
unsigned int getOptionBits()
Return the bit field of various command line options enabled.
Definition: sstinfo.h:50
SSTInfoElement_ParamInfo * getParamInfo(int index)
Return a Parameter Info Object.
Definition: sstinfo.h:458
Describes a Module.
Definition: element.h:112
const char * getValidEvent(unsigned int index)
Return the a specific Valid Events.
Definition: sstinfo.cc:932
const char * getUnits()
Return the Units of the Statistic.
Definition: sstinfo.h:222
SSTInfoElement_ParamInfo * getParamInfo(int index)
Return a Parameter Info Object.
Definition: sstinfo.h:511
const ElementInfoPort * ports
Definition: element.h:86
void generateLibraryInfoXMLData(int LibIndex, TiXmlNode *XMLParentElement)
Create the formatted XML data of the Library.
Definition: sstinfo.cc:761
const char * name
Definition: element.h:73
const char * description
Definition: element.h:124
SSTInfoElement_ParamInfo * getParamInfo(int index)
Return a Parameter Info Object.
Definition: sstinfo.h:298
int getNumberOfLibraryPartitioners()
Return the number of Partitioners within the Library.
Definition: sstinfo.h:652
const uint8_t enableLevel
Definition: element.h:59
uint32_t getCategoryValue()
Return the Category value of the Component.
Definition: sstinfo.h:311
const ElementInfoParam * params
Definition: element.h:118
const char * description
Definition: element.h:145
const char * description
Definition: element.h:154
const ElementInfoParam * params
Definition: element.h:85
const char * name
Definition: element.h:135
Describes Ports that the Component can use.
Definition: element.h:72
The SSTInfo representation of ElementInfoPartitioner object.
Definition: sstinfo.h:541
const char * name
Definition: element.h:123
SSTInfoElement_PortInfo(const ElementInfoPort *elport)
Create a new SSTInfoElement_PortInfo object.
Definition: sstinfo.h:139
Definition: element.h:122
const char * name
Definition: element.h:144
const char * getDesc()
Return the Description of the Component.
Definition: sstinfo.h:293
The SSTInfo representation of ElementInfoPort object.
Definition: sstinfo.h:204
SSTInfoElement_ComponentInfo(const ElementInfoComponent *elc)
Create a new SSTInfoElement_ComponentInfo object.
Definition: sstinfo.h:268
void outputGeneratorInfo(int Index)
Output the Generator Information.
Definition: sstinfo.cc:1223
std::string getLibraryName()
Return the Name of the Library.
Definition: sstinfo.h:631
void outputSubComponentInfo(int Index)
Output the SubComponent Information.
Definition: sstinfo.cc:1156
const char * units
Definition: element.h:58
The SSTInfo representation of ElementInfoSubComponent object.
Definition: sstinfo.h:482
const char * getCategoryString()
Return the name of the Category of the Component.
Definition: sstinfo.h:314