Changeset 4256 in orxonox.OLD for orxonox/branches/levelLoader/src/util/loading

Timestamp:

May 22, 2005, 2:31:08 AM (20 years ago)

Author:

bensch

Message:

orxonox/branches/levelLoader: doxygen-tags

Location:

orxonox/branches/levelLoader/src/util/loading

Files:

• load_param.cc (modified) (11 diffs)
• load_param.h (modified) (4 diffs)

orxonox/branches/levelLoader/src/util/loading/load_param.cc

@@ -21 +21 @@
 #include <stdarg.h>
 
-
+/**
+   \param object The object this Parameter is loaded too.
+   \param paramName The name of the parameter loaded.
+   \param paramCount how many parameters this loading-function takes
+   \param ... the parameter information
+*/
 BaseLoadParam::BaseLoadParam(BaseObject* object, const char* paramName, int paramCount, ...)
 {
@@ -48 +53 @@
 }
 
-
+/**
+   \param descriptionText The text to set as a description for this Parameter
+*/
 void BaseLoadParam::describe(const char* descriptionText)
 {
@@ -57 +64 @@
 }
 
+/**
+   \param paramName the name of the parameter to load
+*/
 LoadParamDescription::LoadParamDescription(const char* paramName)
 {
@@ -65 +75 @@
 }
 
-
+/**
+   \brief removes all the alocated memory
+*/
 LoadParamDescription::~LoadParamDescription(void)
 {
@@ -74 +86 @@
   delete []this->types;
   delete []this->paramName;
-}
-
+  delete []this->description;
+}
+
+/**
+   \param descriptionText The text to set as a description for this Parameter
+*/
 void LoadParamDescription::setDescription(const char* descriptionText)
 {
-  this->description = descriptionText;
-}
-
+  this->description = new char[strlen(descriptionText)+1];
+  strcpy(this->description, descriptionText);
+}
+
+/**
+   \brief prints out this parameter, its input method and the description (if availiable)
+*/
 void LoadParamDescription::print(void) const
 {
@@ -96 +116 @@
 }
 
-
+/**
+   \brief A list, that holds all the classes that are loadable (classes not objects!!)
+*/
 tList<LoadClassDescription>* LoadClassDescription::classList = new tList<LoadClassDescription>;
 
@@ -104 +126 @@
 bool LoadClassDescription::parametersDescription = true;
 
+/**
+   \param className the name of the class to be loadable
+*/
 LoadClassDescription::LoadClassDescription(const char* className)
 {
@@ -114 +139 @@
 }
 
-
+/**
+   \brief deletes a classDescription (deletes all the parameterDescriptions as well
+*/
 LoadClassDescription::~LoadClassDescription(void)
 {
@@ -129 +156 @@
 }
 
-
+/**
+   \brief adds a class to the list of loadable classes
+   \param className The name of the class to add
+
+   this function searches for the className string, and if found just returns the appropriate Class.
+   Otherwise it returns a new classDescription
+*/
 LoadClassDescription* LoadClassDescription::addClass(const char* className)
 {
@@ -148 +181 @@
 }
 
-
+/**
+   \brief does the same as addClass(const char* className), but with params
+   \param paramName the name of the parameter to add.
+*/
 LoadParamDescription* LoadClassDescription::addParam(const char* paramName)
 {
@@ -168 +204 @@
 }
 
+/**
+   \brief prints out all loadable Classes, and their parameters
+*/
 void LoadClassDescription::printAll(void) 
 {

orxonox/branches/levelLoader/src/util/loading/load_param.h

@@ -155 +155 @@
 
 
+//! A class that handles the description of loadable parameters
 class LoadParamDescription
 {
@@ -169 +170 @@
   void print(void) const;
  private:
-  char* paramName;
-  int paramCount;
-  char** types;
-  const char* description;
+  char* paramName;              //!< The name of the parameter
+  int paramCount;               //!< The count of parameters
+  char** types;                 //!< What kind of parameters does this function take ??
+  char* description;            //!< A longer description about this function
 };
 
@@ -187 +188 @@
   static void printAll(void);
 
-  static bool parametersDescription;  
-  static tList<LoadClassDescription>* classList;
+  static bool parametersDescription;             //!< if parameter-description should be enabled.
+  static tList<LoadClassDescription>* classList; //!< a list, that holds all the loadable classes. (after one instance has been loaded)
  private:
-  char* className;
-  tList<LoadParamDescription>* paramList;
+  char* className;                               //!< name of the class
+  tList<LoadParamDescription>* paramList;        //!< List of parameters this class knows.
 };
 
@@ -204 +205 @@
 
  protected:
-  LoadClassDescription* classDesc;
-  LoadParamDescription* paramDesc;
-};
-
-
-// derived template class
+  LoadClassDescription* classDesc;               //!< The LoadClassDescription of this LoadParameter
+  LoadParamDescription* paramDesc;               //!< The LoadParameterDescription of this LoadParameter
+};
+
+
+//! derived template class, so all the Classes can load something.
 template<class T> class LoadParam : public BaseLoadParam
 {