Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9763 in orxonox.OLD for branches/new_class_id/src


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

more doc

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

Legend:

Unmodified
Added
Removed

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

    r9729 r9763  
    2121#include "debug.h"
    2222/**
    23  * Constructs a new LoadParameter
     23 * @brief Constructs a new LoadParameter
    2424 * @param root the XML-element to load this Parameter from
    2525 * @param paramName the Parameter to load
    2626 * @param object the BaseObject, to load this parameter on to (will be cast to executor's Parameter)
    27  * @param executor the Executor, that executes the loading procedure.
     27 * @param inLoadCycle If we are in a LoadCycle (loading differs.).
    2828 */
    2929LoadParamBase::LoadParamBase(const TiXmlElement* root, const std::string& paramName, BaseObject* object, bool inLoadCycle)
    … …  
    5454
    5555
    56 
     56/**
     57 * @brief generates a LoadParam based on
     58 * @param root the Root Element to load onto the object.
     59 * @param paramName the Parameter name that is loaded.
     60 * @param object the Object to apply the changes on.
     61 * @param executor the Functional Object, that actually executes the function Call.
     62 * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
     63 */
    5764CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor<const SubString>* executor, bool inLoadCycle)
    5865    : LoadParamBase(root, paramName, object, inLoadCycle)

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

    r9742 r9763  
    3737/**
    3838 * Loads a Parameter from ROOT named PARAMETER_NAME
    39  * onto OBJECT of CLASS, trough the FUNCTION
     39 * onto OBJECT of CLASS, trough FUNCTION
    4040 * @param ROOT the TiXmlElement to load the Parameter from
    4141 * @param PARAMETER_NAME the Name of the Parameter to load
    … …  
    4747         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), false)
    4848
     49/**
     50 * @brief Does essentially the same as LoadParam, but within a Cycle in an ordered fashion.
     51 *
     52 * This Function looks in each Element, if the PARAMETER_NAME matches, and loads onto OBJECT
     53 * of CLASS the ROOT through FUNCTION
     54 *
     55 * @see LoadParam(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION)
     56 */
    4957#define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
    5058         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), true)
    … …  
    7785**** REAL DECLARATIONS ****
    7886**************************/
    79 class LoadParamBase : public BaseObject
     87//!< A BaseClass for all LoadParam's.
     88class LoadParamBase
    8089{
    8190protected:
    … …  
    8695
    8796protected:
    88   BaseObject*              object;
    89   const std::string        paramName;
    90   bool                     inLoadCycle;
     97  BaseObject*              object;               //!< The Object to work on
     98  const std::string        paramName;            //!< The Name of the Parameter this LoadParams applies to.
     99  bool                     inLoadCycle;          //!< If the Parameter is in a LoadCycle.
    91100
    92101  LoadClassDescription*    classDesc;            //!< The LoadClassDescription of this CLoadParameter
    … …  
    96105
    97106
    98 //! abstract Base class for a Loadable parameter
     107//! The Loading Class of the LoadParam, that acctually executes the loading process.
    99108class CLoadParam : public LoadParamBase
    100109{
    … …  
    111120
    112121private:
    113   Executor<const SubString>*         executor;
     122  Executor<const SubString>*         executor;            //!< The Executor, that actually executes the Loading process.
    114123};
    115124

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

    r9727 r9763  
    1919#include "load_param_description.h"
    2020
     21
     22/**
     23 * @brief generates a LoadParam based on
     24 * @param root the Root Element to load onto the object.
     25 * @param paramName the Parameter name that is loaded.
     26 * @param object the Object to apply the changes on.
     27 * @param executor the Functional Object, that actually executes the function Call.
     28 * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
     29 */
    2130XmlLoadParam::XmlLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor<const TiXmlElement*>* executor, bool inLoadCycle )
    2231    : LoadParamBase(root, paramName, object, inLoadCycle)

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

    r9727 r9763  
    2525#include "executor/executor_xml.h"
    2626
     27/**
     28 * @brief Loads a Parameter from ROOT named PARAMETER_NAME
     29 * onto OBJECT of CLASS, trough FUNCTION
     30 * @param ROOT the TiXmlElement to load the Parameter from
     31 * @param PARAMETER_NAME the Name of the Parameter to load
     32 * @param OBJECT The BaseObject to load the new setting to.
     33 * @param CLASS What Class the BaseObejct is of (this is for identifying the Functuon)
     34 * @param FUNCTION The function of Class to Load (if you want to call &CLASS::FUNCTION write FUNCTION here).
     35 */
    2736#define LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
    2837         XmlLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
    2938
     39
     40/**
     41 * @brief Does essentially the same as LoadParamXML, but within a Cycle in an ordered fashion.
     42 *
     43 * This Function looks in each Element, if the PARAMETER_NAME matches, and loads onto OBJECT
     44 * of CLASS the ROOT through FUNCTION
     45 *
     46 * @see LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION)
     47 */
    3048#define LoadParamXML_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
    3149         XmlLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
    3250
     51//! A Class that can load XML tags onto an Object.
    3352class XmlLoadParam : public LoadParamBase
    3453{
    … …  
    3756    virtual ~XmlLoadParam();
    3857
     58    /** @param descriptionText the description @returns self @brief describes the Loading parameter. */
    3959    XmlLoadParam& describe(const std::string& descriptionText) { LoadParamBase::describe(descriptionText); return *this; };
    4060
    4161  private:
    42     Executor<const TiXmlElement*>*    executor;
     62    Executor<const TiXmlElement*>*    executor;       //!< The Executor, that does the actual loading process.
    4363};
    4464
Note: See TracChangeset for help on using the changeset viewer.