Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9765 in orxonox.OLD for branches/new_class_id


Ignore:
Timestamp:
Sep 19, 2006, 5:49:58 PM (18 years ago)
Author:
bensch
Message:

compiles again

Location:
branches/new_class_id/src/lib/util/loading
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • branches/new_class_id/src/lib/util/loading/load_param.cc

    r9763 r9765  
    1717
    1818#include "util/loading/load_param.h"
    19 #include "load_param_description.h"
     19#include "load_param_class_description.h"
    2020#include "compiler.h"
    2121#include "debug.h"
    … …  
    4646void LoadParamBase::describe(const std::string& descriptionText)
    4747{
    48   if (LoadClassDescription::parametersDescription && this->paramDesc && this->paramDesc->getDescription().empty())
     48  /// TODO REIMPLEMENT
     49  /*  if (LoadParamClassDescription::parametersDescription && this->paramDesc && this->paramDesc->getDescription().empty())
    4950  {
    5051    this->paramDesc->setDescription(descriptionText);
    51   }
     52  }*/
    5253}
    5354
    … …  
    115116
    116117
    117 // const LoadParamDescription* LoadParamDescription::getClass(const char* className)
    118 // {
    119 //   tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
    120 //   LoadClassDescription* enumClassDesc = iterator->firstElement();
    121 //   while (enumClassDesc)
    122 //   {
    123 //     if (!strcmp(enumClassDesc->className, classNameBegin, className))
    124 //     {
    125 //       delete iterator;
    126 //       return enumClassDesc;
    127 //     }
    128 //     enumClassDesc = iterator->nextElement();
    129 //   }
    130 //   delete iterator;
    131 //
    132 //   return NULL;
    133 // }
    134 
    135 
    136 
    137 
    138 /*
    139  * @param object The object this Parameter is loaded too.
    140  * @param root: the XML-element to load this option from.
    141  * @param paramName: The name of the parameter loaded.
    142  * @param paramCount: how many parameters this loading-function takes
    143  * @param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
    144  * @param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
    145 */
    146 /*LoadParam::LoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName,
    147                              int paramCount, bool multi, const void* pointerToParam, ...)
    148 {
    149   this->setClassID(CL_LOAD_PARAM, "LoadParam");
    150   this->executor = NULL;
    151 
    152   this->loadString = NULL;
    153   this->pointerToParam = pointerToParam;
    154 
    155   if (paramCount == 0 || this->pointerToParam != NULL)
    156     this->loadString = "none";
    157   else
    158 {
    159       if (likely(!multi))
    160         this->loadString = grabParameter(root, paramName);
    161       else
    162 {
    163           if (!strcmp(root->Value(), paramName))
    164 {
    165               const TiXmlNode* val = root->FirstChild();
    166               if( val->ToText())
    167                 this->loadString = val->Value();
    168 }
    169 }
    170 }
    171 
    172   this->paramDesc = NULL;
    173   if (LoadClassDescription::parametersDescription)
    174 {
    175     // locating the class
    176     this->classDesc = LoadClassDescription::addClass(object->getClassCName());
    177 
    178     if ((this->paramDesc = this->classDesc->addParam(paramName)) != NULL)
    179 {
    180 
    181       this->paramDesc->paramCount = paramCount;
    182       this->paramDesc->types = new int[paramCount];
    183       this->paramDesc->defaultValues = new char*[paramCount];
    184 
    185       va_list types;
    186       va_start (types, pointerToParam);
    187       char defaultVal[512];
    188       for(int i = 0; i < paramCount; i++)
    189 {
    190         defaultVal[0] = '\0';
    191           // parameters parsed
    192         int tmpType = va_arg (types, int);
    193         this->paramDesc->types[i] = tmpType;
    194         switch (tmpType)
    195 {
    196   case MT_INT:
    197             sprintf(defaultVal, "%d", va_arg(types, int));
    198             break;
    199 //          case MT_LONG:
    200 //            sprintf(defaultVal, "%0.3f", va_arg(types, l_LONG_TYPE));
    201 //            break;
    202   case MT_FLOAT:
    203             sprintf(defaultVal, "%0.3f", va_arg(types, double));
    204             break;
    205   case MT_STRING:
    206             sprintf(defaultVal, "%s", va_arg(types, l_STRING_TYPE));
    207             break;
    208   case MT_EXT1:
    209             sprintf(defaultVal, "");
    210             break;
    211 }
    212         this->paramDesc->defaultValues[i] = new char[strlen(defaultVal)+1];
    213         strcpy(this->paramDesc->defaultValues[i], defaultVal);
    214 }
    215       va_end(types);
    216 
    217       int argCount = 0;
    218 }
    219 }
    220 }*/
    221 
    222 
    223 
    224 
    225 
    226 
    227 
    228 
    229 
    230 
    231118//////////////////////
    232119// HELPER FUNCTIONS //

  • branches/new_class_id/src/lib/util/loading/load_param.h

    r9763 r9765  
    9999  bool                     inLoadCycle;          //!< If the Parameter is in a LoadCycle.
    100100
    101   LoadClassDescription*    classDesc;            //!< The LoadClassDescription of this CLoadParameter
    102   LoadParamDescription*    paramDesc;            //!< The LoadParameterDescription of this LoadParameter
    103101  const TiXmlElement*      loadElem;             //!< The Element to load.
    104102};

  • branches/new_class_id/src/lib/util/loading/load_param_class_description.cc

    r9764 r9765  
    1414*/
    1515
    16 #include "load_param_description.h"
     16#include "load_param_class_description.h"
    1717
    1818#include "multi_type.h"
    … …  
    125125 *  A list, that holds all the classes that are loadable (classes not objects!!)
    126126 */
    127 std::list<LoadClassDescription*>* LoadClassDescription::classList = NULL;
     127std::list<LoadParamClassDescription*>* LoadParamClassDescription::classList = NULL;
    128128
    129129/**
    130130 *  if the description of Parameters should be executed
    131131 */
    132 bool LoadClassDescription::parametersDescription = false;
     132bool LoadParamClassDescription::parametersDescription = false;
    133133
    134134/**
    135135 * @param className the name of the class to be loadable
    136136 */
    137 LoadClassDescription::LoadClassDescription(const std::string& className)
     137LoadParamClassDescription::LoadParamClassDescription(const std::string& className)
    138138{
    139139  this->className = className;
    140140
    141   if (LoadClassDescription::classList == NULL)
    142     LoadClassDescription::classList = new std::list<LoadClassDescription*>;
    143 
    144   LoadClassDescription::classList->push_back(this);
     141  if (LoadParamClassDescription::classList == NULL)
     142    LoadParamClassDescription::classList = new std::list<LoadParamClassDescription*>;
     143
     144  LoadParamClassDescription::classList->push_back(this);
    145145}
    146146
    … …  
    148148 *  deletes a classDescription (deletes all the parameterDescriptions as well
    149149 */
    150 LoadClassDescription::~LoadClassDescription()
     150LoadParamClassDescription::~LoadParamClassDescription()
    151151{
    152152  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
    … …  
    158158}
    159159
    160 void LoadClassDescription::deleteAllDescriptions()
    161 {
    162   if (LoadClassDescription::classList != NULL)
    163   {
    164     while (!LoadClassDescription::classList->empty())
    165     {
    166       delete LoadClassDescription::classList->front();
    167       LoadClassDescription::classList->pop_front();
    168     }
    169     delete LoadClassDescription::classList;
    170   }
    171   LoadClassDescription::classList = NULL;
     160void LoadParamClassDescription::deleteAllDescriptions()
     161{
     162  if (LoadParamClassDescription::classList != NULL)
     163  {
     164    while (!LoadParamClassDescription::classList->empty())
     165    {
     166      delete LoadParamClassDescription::classList->front();
     167      LoadParamClassDescription::classList->pop_front();
     168    }
     169    delete LoadParamClassDescription::classList;
     170  }
     171  LoadParamClassDescription::classList = NULL;
    172172}
    173173
    … …  
    180180   Otherwise it returns a new classDescription
    181181 */
    182 LoadClassDescription* LoadClassDescription::addClass(const std::string& className)
    183 {
    184   if (LoadClassDescription::classList != NULL)
    185   {
    186     std::list<LoadClassDescription*>::iterator it = LoadClassDescription::classList->begin();
    187     while (it != LoadClassDescription::classList->end())
     182LoadParamClassDescription* LoadParamClassDescription::addClass(const std::string& className)
     183{
     184  if (LoadParamClassDescription::classList != NULL)
     185  {
     186    std::list<LoadParamClassDescription*>::iterator it = LoadParamClassDescription::classList->begin();
     187    while (it != LoadParamClassDescription::classList->end())
    188188    {
    189189      if ((*it)->className == className)
    … …  
    194194    }
    195195  }
    196   return new LoadClassDescription(className);
     196  return new LoadParamClassDescription(className);
    197197}
    198198
    … …  
    201201 * @param paramName the name of the parameter to add.
    202202 */
    203 LoadParamDescription* LoadClassDescription::addParam(const std::string& paramName)
     203LoadParamDescription* LoadParamClassDescription::addParam(const std::string& paramName)
    204204{
    205205  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
    … …  
    224224 * @todo implement it
    225225 */
    226 void LoadClassDescription::printAll(const std::string& fileName)
     226void LoadParamClassDescription::printAll(const std::string& fileName)
    227227{
    228228  PRINT(3)("===============================================================\n");
    229229  PRINT(3)(" Listing all the Loadable Options (loaded since Game started).\n\n");
    230   if (LoadClassDescription::classList != NULL)
    231   {
    232     std::list<LoadClassDescription*>::iterator classDesc = LoadClassDescription::classList->begin();
    233     while (classDesc != LoadClassDescription::classList->end())
     230  if (LoadParamClassDescription::classList != NULL)
     231  {
     232    std::list<LoadParamClassDescription*>::iterator classDesc = LoadParamClassDescription::classList->begin();
     233    while (classDesc != LoadParamClassDescription::classList->end())
    234234    {
    235235      PRINT(3)("<%s>\n", (*classDesc)->className.c_str());
    … …  
    255255 * !! The strings MUST NOT be deleted !!
    256256 */
    257 std::list<std::string> LoadClassDescription::searchClassWithShort(const std::string& classNameBegin)
     257std::list<std::string> LoadParamClassDescription::searchClassWithShort(const std::string& classNameBegin)
    258258{
    259259  /// FIXME
    … …  
    262262  std::list<const std::string&> retVal;
    263263
    264   tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
    265   LoadClassDescription* enumClassDesc = iterator->firstElement();
     264  tIterator<LoadParamClassDescription>* iterator = LoadParamClassDescription::classList->getIterator();
     265  LoadParamClassDescription* enumClassDesc = iterator->firstElement();
    266266  while (enumClassDesc)
    267267  {

  • branches/new_class_id/src/lib/util/loading/load_param_class_description.h

    r9764 r9765  
    1515
    1616/*!
    17  * @file load_param.h
     17 * @file load_param_class_description.h
    1818 * A Class and macro-functions, that makes our lives easy to load-in parameters
    1919 */
    2020
    21 #ifndef _LOAD_PARAM_DESCRIPTION_H
    22 #define _LOAD_PARAM_DESCRIPTION_H
     21#ifndef _LOAD_PARAM_CLASS_DESCRIPTION_H
     22#define _LOAD_PARAM_CLASS_DESCRIPTION_H
    2323
    24 #include <list>
    25 #include <string>
     24#include "load_param_description.h"
     25#include <set>
    2626
    2727// Forward Declaration //
    2828class MultiType;
    2929
    30 /************************
    31 *** DESCRIPTION STUFF ***
    32 ************************/
    33 //! A class that handles the description of loadable parameters
    34 class LoadParamDescription
     30//! A class for descriptions of a loadable module
     31class LoadParamClassDescription
    3532{
    36   friend class LoadParam;
    37   friend class LoadClassDescription;
    3833public:
    39   LoadParamDescription(const std::string& paramName);
    40   ~LoadParamDescription();
     34  LoadParamClassDescription(const std::string& className);
     35  ~LoadParamClassDescription();
    4136
    42   void setDescription(const std::string& descriptionText);
    43   /** @returns the descriptionString */
    44   const std::string& getDescription() { return this->description; };
     37  bool operator==(const std::string& className) const { return this->className == className; };
     38  bool operator==(const LoadParamClassDescription& classDescr) const { return this->className == classDescr.className; };
     39  bool operator<(const LoadParamClassDescription& classDescr) const { return this->className < classDescr.className; }
    4540
    46   void print() const;
    47 
    48 private:
    49   std::string                description;           //!< A longer description about this function.
    50 
    51   std::vector<std::string>   parameters;
    52   std::vector<std::string>   defaultValues;
    53 
    54 };
    55 
    56 
    57 
    58 
    59 //! A class for descriptions of a loadable module
    60 class LoadClassDescription
    61 {
    62   friend class LoadParamBase;
    63 public:
    64   LoadClassDescription(const std::string& className);
    65   ~LoadClassDescription();
    66 
    67   static LoadClassDescription* addClass(const std::string& className);
     41  static LoadParamClassDescription* addClass(const std::string& className);
    6842  LoadParamDescription* addParam(const std::string& paramName);
    6943
    … …  
    7549
    7650private:
     51  typedef std::set<LoadParamClassDescription>  ClassDescriptionSet;
     52  typedef std::set<LoadParamDescription>       ParamDescriptionSet;
     53
    7754  static bool                                  parametersDescription;  //!< if parameter-description should be enabled.
    78   static std::vector<LoadClassDescription*>*   classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)
     55  static ClassDescriptionSet*                  classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)
    7956  std::string                                  className;              //!< name of the class
    8057
    81   std::vector<LoadParamDescription*>           paramList;              //!< List of parameters this class knows.
     58  ParamDescriptionSet                          parameters;              //!< List of parameters this class knows.
    8259};
    8360
    84 #endif /* _LOAD_PARAM_DESCRIPTION_H */
     61#endif /* _LOAD_PARAM_CLASS_DESCRIPTION_H */

  • branches/new_class_id/src/lib/util/loading/load_param_description.cc

    r8362 r9765  
    1717
    1818#include "multi_type.h"
    19 #include <stdarg.h>
    2019#include "debug.h"
    2120
    … …  
    2423 */
    2524LoadParamDescription::LoadParamDescription(const std::string& paramName)
    26 {
    27   this->types = NULL;
    28   this->defaultValues = NULL;
    29   this->paramName = paramName;
    30 }
     25  : name(paramName)
     26{ }
    3127
    3228/**
    … …  
    3531LoadParamDescription::~LoadParamDescription()
    3632{
    37   if (this->defaultValues != NULL)
    38   {
    39     for(int i = 0; i < this->paramCount; i++)
    40     {
    41       delete[] this->defaultValues[i];
    42     }
    43   }
    44 
    45   delete[] this->types;
    46   delete[] this->defaultValues;
    4733}
    4834
    … …  
    6046void LoadParamDescription::print() const
    6147{
    62   PRINT(3)(" <%s>", this->paramName.c_str());
    63   for (int i = 0; i < this->paramCount; i++)
     48  PRINT(3)(" <%s>", this->name.c_str());
     49  for (unsigned int i = 0; i < this->parameterCount; i++)
    6450  {
    6551    if (i > 0)
    … …  
    9783//     }
    9884  }
    99   PRINT(3)("</%s>", this->paramName.c_str());
     85  PRINT(3)("</%s>", this->name.c_str());
    10086  if (!this->description.empty())
    10187    PRINT(3)(" -- %s", this->description.c_str());
    10288  // default values
    103   if (this->paramCount > 0)
     89  if (this->parameterCount > 0)
    10490  {
    10591    PRINT(3)(" (Default: ");
    106     for (int i = 0; i < this->paramCount; i++)
     92    for (unsigned int i = 0; i < this->parameterCount; i++)
    10793    {
    10894      if (i > 0)
    10995        PRINT(3)(", ");
    110       if (this->types[i] & MT_STRING)
     96      if (this->types[i] == "string")
    11197      { // leave brackets !!
    112         PRINT(3)("\"%s\"", this->defaultValues[i]);
     98        PRINT(3)("\"%s\"", this->defaultValues[i].c_str());
    11399      }
    114100      else
    115101      {
    116         PRINT(3)("%s", this->defaultValues[i]);
     102        PRINT(3)("%s", this->defaultValues[i].c_str());
    117103      }
    118104    }
    … …  
    121107  PRINT(3)("\n");
    122108}
    123 
    124 /**
    125  *  A list, that holds all the classes that are loadable (classes not objects!!)
    126  */
    127 std::list<LoadClassDescription*>* LoadClassDescription::classList = NULL;
    128 
    129 /**
    130  *  if the description of Parameters should be executed
    131  */
    132 bool LoadClassDescription::parametersDescription = false;
    133 
    134 /**
    135  * @param className the name of the class to be loadable
    136  */
    137 LoadClassDescription::LoadClassDescription(const std::string& className)
    138 {
    139   this->className = className;
    140 
    141   if (LoadClassDescription::classList == NULL)
    142     LoadClassDescription::classList = new std::list<LoadClassDescription*>;
    143 
    144   LoadClassDescription::classList->push_back(this);
    145 }
    146 
    147 /**
    148  *  deletes a classDescription (deletes all the parameterDescriptions as well
    149  */
    150 LoadClassDescription::~LoadClassDescription()
    151 {
    152   std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
    153   while (!this->paramList.empty())
    154   {
    155     delete this->paramList.front();
    156     this->paramList.pop_front();
    157   }
    158 }
    159 
    160 void LoadClassDescription::deleteAllDescriptions()
    161 {
    162   if (LoadClassDescription::classList != NULL)
    163   {
    164     while (!LoadClassDescription::classList->empty())
    165     {
    166       delete LoadClassDescription::classList->front();
    167       LoadClassDescription::classList->pop_front();
    168     }
    169     delete LoadClassDescription::classList;
    170   }
    171   LoadClassDescription::classList = NULL;
    172 }
    173 
    174 
    175 /**
    176  *  adds a class to the list of loadable classes
    177  * @param className The name of the class to add
    178 
    179    this function searches for the className string, and if found just returns the appropriate Class.
    180    Otherwise it returns a new classDescription
    181  */
    182 LoadClassDescription* LoadClassDescription::addClass(const std::string& className)
    183 {
    184   if (LoadClassDescription::classList != NULL)
    185   {
    186     std::list<LoadClassDescription*>::iterator it = LoadClassDescription::classList->begin();
    187     while (it != LoadClassDescription::classList->end())
    188     {
    189       if ((*it)->className == className)
    190       {
    191         return (*it);
    192       }
    193       it++;
    194     }
    195   }
    196   return new LoadClassDescription(className);
    197 }
    198 
    199 /**
    200  *  does the same as addClass(const std::string& className), but with params
    201  * @param paramName the name of the parameter to add.
    202  */
    203 LoadParamDescription* LoadClassDescription::addParam(const std::string& paramName)
    204 {
    205   std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
    206   while (it != this->paramList.end())
    207   {
    208     if ((*it)->paramName == paramName)
    209     {
    210       return NULL;
    211     }
    212     it++;
    213   }
    214 
    215   LoadParamDescription* newParam = new LoadParamDescription(paramName);
    216 
    217   this->paramList.push_back(newParam);
    218   return newParam;
    219 }
    220 
    221 /**
    222  *  prints out all loadable Classes, and their parameters
    223  * @param fileName prints the output to a File
    224  * @todo implement it
    225  */
    226 void LoadClassDescription::printAll(const std::string& fileName)
    227 {
    228   PRINT(3)("===============================================================\n");
    229   PRINT(3)(" Listing all the Loadable Options (loaded since Game started).\n\n");
    230   if (LoadClassDescription::classList != NULL)
    231   {
    232     std::list<LoadClassDescription*>::iterator classDesc = LoadClassDescription::classList->begin();
    233     while (classDesc != LoadClassDescription::classList->end())
    234     {
    235       PRINT(3)("<%s>\n", (*classDesc)->className.c_str());
    236       std::list<LoadParamDescription*>::iterator param = (*classDesc)->paramList.begin();
    237       while (param != (*classDesc)->paramList.end())
    238       {
    239         (*param)->print();
    240         param++;
    241       }
    242       PRINT(3)("</%s>\n\n", (*classDesc)->className.c_str());
    243       classDesc++;
    244     }
    245   }
    246   else
    247     PRINT(3)("no Classes defined so far\n");
    248   PRINT(3)("===============================================================\n");
    249 }
    250 
    251 /**
    252  * searches for classes, which beginn with classNameBegin
    253  * @param classNameBegin the beginning string of a Class
    254  * @return a NEW char-array with ClassNames. The LIST should be deleted afterwards,
    255  * !! The strings MUST NOT be deleted !!
    256  */
    257 std::list<std::string> LoadClassDescription::searchClassWithShort(const std::string& classNameBegin)
    258 {
    259   /// FIXME
    260   // NOT USED
    261 /*  unsigned int searchLength = strlen(classNameBegin);
    262   std::list<const std::string&> retVal;
    263 
    264   tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
    265   LoadClassDescription* enumClassDesc = iterator->firstElement();
    266   while (enumClassDesc)
    267   {
    268     if (strlen(enumClassDesc->className)>searchLength+1 &&
    269         !strncasecmp(enumClassDesc->className, classNameBegin, searchLength))
    270     {
    271       retVal->add(enumClassDesc->className);
    272     }
    273     enumClassDesc = iterator->nextElement();
    274   }
    275   delete iterator;
    276 
    277   return retVal;*/
    278   std::list<std::string> a;
    279   return a;
    280 }

  • branches/new_class_id/src/lib/util/loading/load_param_description.h

    r9764 r9765  
    1515
    1616/*!
    17  * @file load_param.h
     17 * @file load_param_description.h
    1818 * A Class and macro-functions, that makes our lives easy to load-in parameters
    1919 */
    … …  
    2222#define _LOAD_PARAM_DESCRIPTION_H
    2323
    24 #include <list>
     24#include <vector>
    2525#include <string>
    2626
    … …  
    3434class LoadParamDescription
    3535{
    36   friend class LoadParam;
    37   friend class LoadClassDescription;
    3836public:
    3937  LoadParamDescription(const std::string& paramName);
    4038  ~LoadParamDescription();
     39
     40  bool operator==(const std::string& paramName) const { return this->name == paramName; };
     41  bool operator==(const LoadParamDescription& paramDescr) const { return this->name == paramDescr.name; };
     42  bool operator<(const LoadParamDescription& paramDescr) const { return this->name < paramDescr.name; };
    4143
    4244  void setDescription(const std::string& descriptionText);
    … …  
    4749
    4850private:
     51  const std::string          name;                  //!< The Name of the Parameter.
     52  unsigned int               parameterCount;        //!< The Count of parameters.
    4953  std::string                description;           //!< A longer description about this function.
    5054
    51   std::vector<std::string>   parameters;
     55  std::vector<std::string>   types;
    5256  std::vector<std::string>   defaultValues;
    5357
    5458};
    5559
    56 
    57 
    58 
    59 //! A class for descriptions of a loadable module
    60 class LoadClassDescription
    61 {
    62   friend class LoadParamBase;
    63 public:
    64   LoadClassDescription(const std::string& className);
    65   ~LoadClassDescription();
    66 
    67   static LoadClassDescription* addClass(const std::string& className);
    68   LoadParamDescription* addParam(const std::string& paramName);
    69 
    70   static void deleteAllDescriptions();
    71 
    72   static void printAll(const std::string& fileName = "");
    73   static std::list<std::string> searchClassWithShort(const std::string& classNameBegin);
    74   //  static const LoadParamDescription* getClass(const std::string& className);
    75 
    76 private:
    77   static bool                                  parametersDescription;  //!< if parameter-description should be enabled.
    78   static std::vector<LoadClassDescription*>*   classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)
    79   std::string                                  className;              //!< name of the class
    80 
    81   std::vector<LoadParamDescription*>           paramList;              //!< List of parameters this class knows.
    82 };
    83 
    8460#endif /* _LOAD_PARAM_DESCRIPTION_H */
Note: See TracChangeset for help on using the changeset viewer.