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