Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 813 for code/branches/core/src


Ignore:
Timestamp:
Feb 15, 2008, 4:31:58 PM (17 years ago)
Author:
landauf
Message:
  • removed IdentifierList and replaced it by a std::list
  • changed several doxygen tags
Location:
code/branches/core/src/orxonox
Files:
2 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • code/branches/core/src/orxonox/core/BaseObject.cc

    r790 r813  
    2020 *
    2121 *   Author:
    22  *      ...
     22 *      Fabian 'x3n' Landau
    2323 *   Co-authors:
    2424 *      ...
    … …  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file BaseObject.cc
    3030    @brief Implementation of the BaseObject class.

  • code/branches/core/src/orxonox/core/BaseObject.h

    r790 r813  
    1 /*!
     1/*
     2 *   ORXONOX - the hottest 3D action shooter ever to exist
     3 *
     4 *
     5 *   License notice:
     6 *
     7 *   This program is free software; you can redistribute it and/or
     8 *   modify it under the terms of the GNU General Public License
     9 *   as published by the Free Software Foundation; either version 2
     10 *   of the License, or (at your option) any later version.
     11 *
     12 *   This program is distributed in the hope that it will be useful,
     13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15 *   GNU General Public License for more details.
     16 *
     17 *   You should have received a copy of the GNU General Public License
     18 *   along with this program; if not, write to the Free Software
     19 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     20 *
     21 *   Author:
     22 *      Fabian 'x3n' Landau
     23 *   Co-authors:
     24 *      ...
     25 *
     26 */
     27
     28/**
    229    @file BaseObject.h
    330    @brief Definition of the BaseObject class.

  • code/branches/core/src/orxonox/core/CMakeLists.txt

    r805 r813  
    11SET( CORE_SRC_FILES
     2  OrxonoxClass.cc
    23  BaseObject.cc
    34  Factory.cc
    4   IdentifierList.cc
    55  Identifier.cc
     6  IdentifierDistributor.cc
    67  MetaObjectList.cc
    7   OrxonoxClass.cc
    88  ConfigValueContainer.cc
    99  Error.cc
    … …  
    1414  Language.cc
    1515  ClassTreeMask.cc
    16   IdentifierDistributor.cc
     16#  Level.cc
    1717)
    1818

  • code/branches/core/src/orxonox/core/ClassFactory.h

    r811 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file ClassFactory.h
    3030    @brief Definition and implementation of the ClassFactory class

  • code/branches/core/src/orxonox/core/ClassManager.h

    r811 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file ClassManager.h
    3030    @brief Definition and Implementation of the ClassManager template.

  • code/branches/core/src/orxonox/core/ClassTreeMask.cc

    r811 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file ClassTreeMask.cc
    3030    @brief Implementation of the ClassTreeMask, ClassTreeMaskNode and ClassTreeMaskIterator classes.
    … …  
    294294    void ClassTreeMask::add(const Identifier* subclass, bool bInclude)
    295295    {
    296         this->add(this->root_, subclass, bInclude);
     296        if (subclass->isA(this->root_->getClass()))
     297            this->add(this->root_, subclass, bInclude);
     298        else
     299        {
     300
     301        }
     302
     303        this->clean();
    297304    }
    298305

  • code/branches/core/src/orxonox/core/ClassTreeMask.h

    r809 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file ClassTreeMask.h
    3030    @brief Definition of the ClassTreeMask, ClassTreeMaskNode and ClassTreeMaskIterator classes.
    … …  
    8282        tree of ClassTreeMask. To build a tree, they store a list of all subnodes.
    8383    */
    84     class ClassTreeMaskNode
     84    class _CoreExport ClassTreeMaskNode
    8585    {
    8686        friend class ClassTreeMask;
    … …  
    120120        subclasses, it steps another step back, and so on.
    121121    */
    122     class ClassTreeMaskIterator
     122    class _CoreExport ClassTreeMaskIterator
    123123    {
    124124        public:
    … …  
    151151        you want to drop useless rules, call the clean() function.
    152152    */
    153     class ClassTreeMask
     153    class _CoreExport ClassTreeMask
    154154    {
    155155        public:

  • code/branches/core/src/orxonox/core/ConfigValueContainer.cc

    r811 r813  
    2525 *
    2626 */
     27
     28/**
     29    @file ConfigValueContainer.cc
     30    @brief Implementation of the ConfigValueContainer class.
     31*/
    2732
    2833#include <fstream>
    … …  
    828833
    829834    /**
    830         @returns a list, containing all entrys in the config-file.
     835        @brief Rreturns a list, containing all entrys in the config-file.
     836        @return The list
    831837    */
    832838    std::list<std::string>& ConfigValueContainer::getConfigFileLines()

  • code/branches/core/src/orxonox/core/ConfigValueContainer.h

    r797 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file ConfigValueContainer.h
    3030    @brief Definition of the ConfigValueContainer class.
    … …  
    7575            ConfigValueContainer(const std::string& classname, const std::string& varname, MultiTypeMath defvalue);
    7676
    77             /** @returns the value. @param value This is only needed to determine the right type. */
     77            /** @brief Returns the configured value. @param value This is only needed to determine the right type. @return The value */
    7878/*            template <typename T>
    7979            inline ConfigValueContainer& getValue(T& value)                           { this->value_.getValue(value); return *this; }

  • code/branches/core/src/orxonox/core/CoreIncludes.h

    r811 r813  
    5252#include "Debug.h"
    5353
     54
     55// All needed macros
    5456/**
    5557    @brief Intern macro, containing the common parts of RegisterObject and RegisterRootObject.
    … …  
    6062    this->setIdentifier(orxonox::ClassManager<ClassName>::getIdentifier()->registerClass(this->getParents(), #ClassName, bRootClass)); \
    6163    if (orxonox::Identifier::isCreatingHierarchy() && this->getParents()) \
    62         this->getParents()->add(this->getIdentifier()); \
     64        this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
    6365    orxonox::ClassManager<ClassName>::getIdentifier()->addObject(this)
    6466
    … …  
    6971#define InternRegisterRootObject(ClassName) \
    7072    if (orxonox::Identifier::isCreatingHierarchy() && !this->getParents()) \
    71         this->setParents(new orxonox::IdentifierList()); \
     73        this->createParents(); \
    7274    InternRegisterObject(ClassName, true)
    7375

  • code/branches/core/src/orxonox/core/CorePrereqs.h

    r805 r813  
    2727
    2828/**
    29  @file  CorePrereq.h
    30  @brief Contains all the necessary forward declarations for all classes, structs and enums.
    31  */
     29    @file  CorePrereq.h
     30    @brief Contains all the necessary forward declarations for all classes, structs and enums.
     31*/
    3232
    3333#ifndef _CorePrereqs_H__
    … …  
    7272  template <class T>
    7373  class ClassManager;
     74  class ClassTreeMask;
     75  class ClassTreeMaskIterator;
     76  class ClassTreeMaskNode;
    7477  class ConfigValueContainer;
    7578  class DebugLevel;
    … …  
    7881  class Identifier;
    7982  class IdentifierDistributor;
    80   class IdentifierList;
    81   class IdentifierListElement;
     83//  class IdentifierList;
     84//  class IdentifierListElement;
    8285  template <class T>
    8386  class Iterator;
    8487  class Language;
    8588  class LanguageEntry;
     89  class Level;
    8690  class MetaObjectList;
    8791  template <class T>

  • code/branches/core/src/orxonox/core/Debug.h

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929 * @file Debug.h
    3030 * @brief Handles the output for different verbose-modes.

  • code/branches/core/src/orxonox/core/DebugLevel.cc

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file DebugLevel.cc
    3030    @brief Implementation of the DebugLevel class.
    … …  
    9999
    100100/**
    101     @returns the soft debug level, stored in the only existing instance of the DebugLevel class, configured in the config-file.
     101    @brief Returns the soft debug level, stored in the only existing instance of the DebugLevel class, configured in the config-file.
     102    @return The soft debug level
    102103*/
    103104int getSoftDebugLevel()

  • code/branches/core/src/orxonox/core/DebugLevel.h

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file DebugLevel.h
    3030    @brief Definition of the DebugLevel class.

  • code/branches/core/src/orxonox/core/Error.cc

    r790 r813  
    2525 *
    2626 */
     27
     28/**
     29    @file Error.cc
     30    @brief Implementation of the Error class.
     31*/
    2732
    2833#include "Debug.h"

  • code/branches/core/src/orxonox/core/Error.h

    r790 r813  
    2626 */
    2727
     28/**
     29    @file Error.h
     30    @brief Definition of the Error class.
     31*/
     32
    2833#ifndef _Error_H__
    2934#define _Error_H__

  • code/branches/core/src/orxonox/core/Factory.cc

    r811 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file Factory.cc
    3030    @brief Implementation of the Factory class.
    … …  
    3939{
    4040    /**
    41         @returns the Identifier with a given name.
     41        @brief Returns the Identifier with a given name.
    4242        @param name The name of the wanted Identifier
     43        @return The Identifier
    4344    */
    4445    Identifier* Factory::getIdentifier(const std::string& name)
    … …  
    4849
    4950    /**
    50         @returns the Identifier with a given network ID.
     51        @brief Returns the Identifier with a given network ID.
    5152        @param id The network ID of the wanted Identifier
     53        @return The Identifier
    5254    */
    5355    Identifier* Factory::getIdentifier(const unsigned int id)

  • code/branches/core/src/orxonox/core/Factory.h

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file Factory.h
    3030    @brief Definition of the Factory and the BaseFactory class.

  • code/branches/core/src/orxonox/core/Identifier.cc

    r811 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file Identifier.cc
    3030    @brief Implementation of the Identifier class.
    … …  
    4949        this->factory_ = 0;
    5050
    51         this->children_ = new IdentifierList;
     51        this->children_ = new std::list<const Identifier*>();
    5252
    5353        // Use a static variable because the classID gets created before main() and that's why we should avoid static member variables
    … …  
    5757
    5858    /**
    59         @brief Destructor: Deletes the IdentifierList containing the children.
     59        @brief Destructor: Deletes the list containing the children.
    6060    */
    6161    Identifier::~Identifier()
    … …  
    6565
    6666    /**
    67         @brief Initializes the Identifier with an IdentifierList containing all parents of the class the Identifier belongs to.
    68         @param parents The IdentifierList containing all parents
     67        @brief Initializes the Identifier with a list containing all parents of the class the Identifier belongs to.
     68        @param parents A list containing all parents
    6969    */
    70     void Identifier::initialize(const IdentifierList* parents)
     70    void Identifier::initialize(std::list<const Identifier*>* parents)
    7171    {
    7272        COUT(4) << "*** Identifier: Initialize " << this->name_ << "-Singleton." << std::endl;
    … …  
    7575        if (parents)
    7676        {
    77             IdentifierListElement* temp1 = parents->first_;
    78             while (temp1)
     77            std::list<const Identifier*>::iterator temp1 = parents->begin();
     78            while (temp1 != parents->end())
    7979            {
    80                 this->parents_.add(temp1->identifier_);
    81                 temp1->identifier_->getChildren().add(this); // We're a child of our parents
     80                this->parents_.insert(this->parents_.end(), *temp1);
     81                (*temp1)->getChildren().insert((*temp1)->getChildren().end(), this); // We're a child of our parents
    8282
    83                 temp1 = temp1->next_;
     83                ++temp1;
    8484            }
    8585        }
    … …  
    118118
    119119    /**
    120         @returns true, if the Identifier is at least of the given type.
     120        @brief Returns true, if the Identifier is at least of the given type.
    121121        @param identifier The identifier to compare with
    122122    */
    123123    bool Identifier::isA(const Identifier* identifier) const
    124124    {
    125         return (identifier == this || this->parents_.isInList(identifier));
     125        return (identifier == this || this->identifierIsInList(identifier, this->parents_));
    126126    }
    127127
    128128    /**
    129         @returns true, if the Identifier is exactly of the given type.
     129        @brief Returns true, if the Identifier is exactly of the given type.
    130130        @param identifier The identifier to compare with
    131131    */
    … …  
    136136
    137137    /**
    138         @returns true, if the assigned identifier is a child of the given identifier.
     138        @brief Returns true, if the assigned identifier is a child of the given identifier.
    139139        @param identifier The identifier to compare with
    140140    */
    141141    bool Identifier::isChildOf(const Identifier* identifier) const
    142142    {
    143         return this->parents_.isInList(identifier);
     143        return this->identifierIsInList(identifier, this->parents_);
    144144    }
    145145
    146146    /**
    147         @returns true, if the assigned identifier is a parent of the given identifier.
     147        @brief Returns true, if the assigned identifier is a parent of the given identifier.
    148148        @param identifier The identifier to compare with
    149149    */
    150150    bool Identifier::isParentOf(const Identifier* identifier) const
    151151    {
    152         return this->children_->isInList(identifier);
     152        return this->identifierIsInList(identifier, *this->children_);
     153    }
     154
     155    /**
     156        @brief Searches for a given identifier in a list and returns whether the identifier is in the list or not.
     157        @param identifier The identifier to look for
     158        @param list The list
     159        @return True = the identifier is in the list
     160    */
     161    bool Identifier::identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list)
     162    {
     163        for (std::list<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
     164            if (identifier == (*it))
     165                return true;
     166
     167        return false;
    153168    }
    154169}

  • code/branches/core/src/orxonox/core/Identifier.h

    r812 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file Identifier.h
    3030    @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
    … …  
    5252#define _Identifier_H__
    5353
     54#include <list>
    5455#include <map>
    5556#include <string>
    … …  
    5960
    6061#include "ObjectList.h"
    61 #include "IdentifierList.h"
     62//#include "IdentifierList.h"
    6263#include "Debug.h"
    6364#include "Iterator.h"
    … …  
    109110            virtual void removeObjects() const = 0;
    110111
    111             /** @returns the name of the class the Identifier belongs to. */
     112            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
    112113            inline const std::string& getName() const { return this->name_; }
    113114
    114             /** @returns the parents of the class the Identifier belongs to. */
    115             inline const IdentifierList& getParents() const { return this->parents_; }
    116 
    117             /** @returns the children of the class the Identifier belongs to. */
    118             inline IdentifierList& getChildren() const { return *this->children_; }
    119 
    120             /** @returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. */
     115            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
     116            inline const std::list<const Identifier*>& getParents() const { return this->parents_; }
     117
     118//            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
     119//            inline const std::list<const Identifier*>& getChildren() const { return (*this->children_); }
     120
     121            /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
    121122            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
    122123
    123             /** @returns the network ID to identify a class through the network. */
     124            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
    124125            inline const unsigned int getNetworkID() const { return this->classID_; }
    125126
    … …  
    127128            void setNetworkID(unsigned int id);
    128129
    129             /** @returns the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variable */
     130            /** @brief Returns the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variable @return The ConfigValueContainer */
    130131            inline ConfigValueContainer* getConfigValueContainer(const std::string& varname)
    131132                { return this->configValues_[varname]; }
    … …  
    139140            Identifier(const Identifier& identifier) {} // don't copy
    140141            virtual ~Identifier();
    141             void initialize(const IdentifierList* parents);
     142            void initialize(std::list<const Identifier*>* parents);
     143
     144            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
     145            inline std::list<const Identifier*>& getParents() { return this->parents_; }
     146
     147            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
     148            inline std::list<const Identifier*>& getChildren() const { return (*this->children_); }
    142149
    143150            /**
    … …  
    159166            }
    160167
    161             IdentifierList parents_;                                    //!< The Parents of the class the Identifier belongs to
    162             IdentifierList* children_;                                  //!< The Children of the class the Identifier belongs to
     168            static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
     169
     170//            IdentifierList parents_;                                    //!< The Parents of the class the Identifier belongs to
     171//            IdentifierList* children_;                                  //!< The Children of the class the Identifier belongs to
     172            std::list<const Identifier*> parents_;                      //!< The Parents of the class the Identifier belongs to
     173            std::list<const Identifier*>* children_;                    //!< The Children of the class the Identifier belongs to
    163174
    164175            std::string name_;                                          //!< The name of the class the Identifier belongs to
    … …  
    194205
    195206        public:
    196             ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass);
     207            ClassIdentifier<T>* registerClass(std::list<const Identifier*>* parents, const std::string& name, bool bRootClass);
    197208            void addObject(T* object);
    198209            void removeObjects() const;
    … …  
    220231    /**
    221232        @brief Registers a class, which means that the name and the parents get stored.
    222         @param parents An IdentifierList, containing the Identifiers of all parents of the class
     233        @param parents A list, containing the Identifiers of all parents of the class
    223234        @param name A string, containing exactly the name of the class
    224235        @param bRootClass True if the class is either an Interface or the BaseObject itself
    … …  
    226237    */
    227238    template <class T>
    228     ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass)
     239    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::list<const Identifier*>* parents, const std::string& name, bool bRootClass)
    229240    {
    230241        COUT(4) << "*** ClassIdentifier: Register Class in " << name << "-Singleton." << std::endl;
    … …  
    383394            }
    384395
    385             /** @returns the assigned identifier. */
     396            /** @brief Returns the assigned identifier. @return The identifier */
    386397            inline const Identifier* getIdentifier() const
    387398                { return this->identifier_; }
    388399
    389             /** @returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
     400            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
    390401            inline bool isA(const Identifier* identifier) const
    391402                { return this->identifier_->isA(identifier); }
    392403
    393             /** @returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
     404            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
    394405            inline bool isDirectlyA(const Identifier* identifier) const
    395406                { return this->identifier_->isDirectlyA(identifier); }
    396407
    397             /** @returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
     408            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
    398409            inline bool isChildOf(const Identifier* identifier) const
    399410                { return this->identifier_->isChildOf(identifier); }
    400411
    401             /** @returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
     412            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
    402413            inline bool isParentOf(const Identifier* identifier) const
    403414                { return this->identifier_->isParentOf(identifier); }

  • code/branches/core/src/orxonox/core/IdentifierDistributor.cc

    r809 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file IdentifierDistributor.cc
    3030    @brief Implementation of the IdentifierDistributor class.

  • code/branches/core/src/orxonox/core/IdentifierDistributor.h

    r809 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file IdentifierDistributor.h
    3030    @brief Definition of the IdentifierDistributor class
    … …  
    4545{
    4646    //! The Identifier Distributor stores all Identifiers and makes sure there are no ambiguities.
    47     class IdentifierDistributor
     47    class _CoreExport IdentifierDistributor
    4848    {
    4949        public:

  • code/branches/core/src/orxonox/core/Iterator.h

    r805 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file Iterator.h
    3030    @brief Definition and implementation of the Iterator class.

  • code/branches/core/src/orxonox/core/Language.cc

    r811 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file Language.cc
    3030    @brief Implementation of the Language and the LanguageEntry class.

  • code/branches/core/src/orxonox/core/Language.h

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file Language.h
    3030    @brief Definition of the Language and the LanguageEntry class.

  • code/branches/core/src/orxonox/core/MetaObjectList.cc

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file MetaObjectList.cc
    3030    @brief Implementation of the MetaObjectList class.

  • code/branches/core/src/orxonox/core/MetaObjectList.h

    r811 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file MetaObjectList.h
    3030    @brief Definition of the MetaObjectList class.

  • code/branches/core/src/orxonox/core/ObjectList.h

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file ObjectList.h
    3030    @brief Definition and implementation of the ObjectList class.
    … …  
    8888//            void remove(OrxonoxClass* object, bool bIterateForwards = true);
    8989
    90             /** @returns the first element in the list */
     90            /** @brief Returns the first element in the list. @return The first element */
    9191            inline static Iterator<T> start()
    9292                { return Iterator<T>(getList()->first_); }
    9393
    94             /** @returns the first element in the list */
     94            /** @brief Returns the first element in the list. @return The first element */
    9595            inline static Iterator<T> begin()
    9696                { return Iterator<T>(getList()->first_); }
    9797
    98             /** @returns the last element in the list */
     98            /** @brief Returns the last element in the list. @return The last element */
    9999            inline static Iterator<T> end()
    100100                { return Iterator<T>(getList()->last_); }
    … …  
    134134
    135135    /**
    136         @returns a pointer to the only existing instance for the given class T.
     136        @brief Returns a pointer to the only existing instance for the given class T. @return The instance
    137137    */
    138138    template <class T>

  • code/branches/core/src/orxonox/core/OrxonoxClass.cc

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file OrxonoxClass.cc
    3030    @brief Implementation of the OrxonoxClass Class.

  • code/branches/core/src/orxonox/core/OrxonoxClass.h

    r792 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file OrxonoxClass.h
    3030    @brief Definition of the OrxonoxClass Class.
    … …  
    3737#define _OrxonoxClass_H__
    3838
     39#include <list>
    3940#include <string>
    4041
    … …  
    5960            void setConfigValues() {};
    6061
    61             /** @returns the Identifier of the object */
     62            /** @brief Returns the Identifier of the object. @return The Identifier */
    6263            inline Identifier* getIdentifier() const { return this->identifier_; }
    6364
    … …  
    6566            inline void setIdentifier(Identifier* identifier) { this->identifier_ = identifier; }
    6667
    67             /** @returns the list of all parents of the object */
    68             inline IdentifierList* getParents() const { return this->parents_; }
     68            /** @brief Returns the list of all parents of the object. @return The list */
     69            inline std::list<const Identifier*>* getParents() const { return this->parents_; }
    6970
    70             /** @brief Sets the Parents of the object. Used by the RegisterObject-macro. */
    71             inline void setParents(IdentifierList* parents) { this->parents_ = parents; }
     71            /** @brief Creates the parents-list. */
     72            inline void createParents() { this->parents_ = new std::list<const Identifier*>(); }
    7273
    73             /** @returns the MetaObjectList of the object, containing a link to all ObjectLists and ObjectListElements the object is registered in. */
     74//            /** @brief Sets the Parents of the object. Used by the RegisterObject-macro. */
     75//            inline void setParents(std::list<const Identifier*>* parents) { this->parents_ = parents; }
     76
     77            /** @brief Returns the MetaObjectList of the object, containing a link to all ObjectLists and ObjectListElements the object is registered in. @return The list */
    7478            inline MetaObjectList& getMetaList() { return this->metaList_; }
    7579
    7680
    77             /** @returns true if the objects class is of the given type or a derivative. */
     81            /** @brief Returns true if the objects class is of the given type or a derivative. */
    7882            inline bool isA(const Identifier* identifier)
    7983                { return this->getIdentifier()->isA(identifier); }
    80             /** @returns true if the objects class is exactly of the given type. */
     84            /** @brief Returns true if the objects class is exactly of the given type. */
    8185            inline bool isDirectlyA(const Identifier* identifier)
    8286                { return this->getIdentifier()->isDirectlyA(identifier); }
    83             /** @returns true if the objects class is a child of the given type. */
     87            /** @brief Returns true if the objects class is a child of the given type. */
    8488            inline bool isChildOf(const Identifier* identifier)
    8589                { return this->getIdentifier()->isChildOf(identifier); }
    86             /** @returns true if the objects class is a parent of the given type. */
     90            /** @brief Returns true if the objects class is a parent of the given type. */
    8791            inline bool isParentOf(const Identifier* identifier)
    8892                { return this->getIdentifier()->isParentOf(identifier); }
    8993
    9094
    91             /** @returns true if the objects class is of the given type or a derivative. */
     95            /** @brief Returns true if the objects class is of the given type or a derivative. */
    9296            inline bool isA(const SubclassIdentifier<class B>* identifier)
    9397                { return this->getIdentifier()->isA(identifier->getIdentifier()); }
    94             /** @returns true if the objects class is exactly of the given type. */
     98            /** @brief Returns true if the objects class is exactly of the given type. */
    9599            inline bool isDirectlyA(const SubclassIdentifier<class B>* identifier)
    96100                { return this->getIdentifier()->isDirectlyA(identifier->getIdentifier()); }
    97             /** @returns true if the objects class is a child of the given type. */
     101            /** @brief Returns true if the objects class is a child of the given type. */
    98102            inline bool isChildOf(const SubclassIdentifier<class B>* identifier)
    99103                { return this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
    100             /** @returns true if the objects class is a parent of the given type. */
     104            /** @brief Returns true if the objects class is a parent of the given type. */
    101105            inline bool isParentOf(const SubclassIdentifier<class B>* identifier)
    102106                { return this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
    103107
    104108
    105             /** @returns true if the objects class is of the given type or a derivative. */
     109            /** @brief Returns true if the objects class is of the given type or a derivative. */
    106110            inline bool isA(const SubclassIdentifier<class B> identifier)
    107111                { return this->getIdentifier()->isA(identifier.getIdentifier()); }
    108             /** @returns true if the objects class is exactly of the given type. */
     112            /** @brief Returns true if the objects class is exactly of the given type. */
    109113            inline bool isDirectlyA(const SubclassIdentifier<class B> identifier)
    110114                { return this->getIdentifier()->isDirectlyA(identifier.getIdentifier()); }
    111             /** @returns true if the objects class is a child of the given type. */
     115            /** @brief Returns true if the objects class is a child of the given type. */
    112116            inline bool isChildOf(const SubclassIdentifier<class B> identifier)
    113117                { return this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
    114             /** @returns true if the objects class is a parent of the given type. */
     118            /** @brief Returns true if the objects class is a parent of the given type. */
    115119            inline bool isParentOf(const SubclassIdentifier<class B> identifier)
    116120                { return this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
    117121
    118122
    119             /** @returns true if the objects class is of the given type or a derivative. */
     123            /** @brief Returns true if the objects class is of the given type or a derivative. */
    120124            inline bool isA(const OrxonoxClass* object)
    121125                { return this->getIdentifier()->isA(object->getIdentifier()); }
    122             /** @returns true if the objects class is exactly of the given type. */
     126            /** @brief Returns true if the objects class is exactly of the given type. */
    123127            inline bool isDirectlyA(const OrxonoxClass* object)
    124128                { return this->getIdentifier()->isDirectlyA(object->getIdentifier()); }
    125             /** @returns true if the objects class is a child of the given type. */
     129            /** @brief Returns true if the objects class is a child of the given type. */
    126130            inline bool isChildOf(const OrxonoxClass* object)
    127131                { return this->getIdentifier()->isChildOf(object->getIdentifier()); }
    128             /** @returns true if the objects class is a parent of the given type. */
     132            /** @brief Returns true if the objects class is a parent of the given type. */
    129133            inline bool isParentOf(const OrxonoxClass* object)
    130134                { return this->getIdentifier()->isParentOf(object->getIdentifier()); }
    … …  
    134138            inline virtual void setName(const std::string& name) { this->name_ = name; }
    135139
    136             /** @returns the name of the object. */
     140            /** @brief Returns the name of the object. @return The name */
    137141            inline const std::string& getName() const { return this->name_; }
    138142
    … …  
    140144            inline virtual void setActive(bool bActive) { this->bActive_ = bActive; }
    141145
    142             /** @returns the state of the objects activity. */
     146            /** @brief Returns the state of the objects activity. @return The state of the activity */
    143147            inline const bool isActive() const { return this->bActive_; }
    144148
    … …  
    146150            inline virtual void setVisible(bool bVisible) { this->bVisible_ = bVisible; }
    147151
    148             /** @returns the state of the objects visibility. */
     152            /** @brief Returns the state of the objects visibility. @return The state of the visibility */
    149153            inline const bool isVisible() const { return this->bVisible_; }
    150154
    151155        private:
    152             Identifier* identifier_;        //!< The Identifier of the object
    153             IdentifierList* parents_;       //!< List of all parents of the object
    154             MetaObjectList metaList_;       //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
     156            Identifier* identifier_;                    //!< The Identifier of the object
     157            std::list<const Identifier*>* parents_;     //!< List of all parents of the object
     158            MetaObjectList metaList_;                   //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
    155159
    156             std::string name_;              //!< The name of the object
    157             bool bActive_;                  //!< True = the object is active
    158             bool bVisible_;                 //!< True = the object is visible
     160            std::string name_;                          //!< The name of the object
     161            bool bActive_;                              //!< True = the object is active
     162            bool bVisible_;                             //!< True = the object is visible
    159163    };
    160164    template class _CoreExport orxonox::ClassIdentifier<OrxonoxClass>;

  • code/branches/core/src/orxonox/core/OutputHandler.cc

    r790 r813  
    2525 *
    2626 */
     27
     28/**
     29    @file OutputHandler.cc
     30    @brief Implementation of the OutputHandler class.
     31*/
    2732
    2833#include "DebugLevel.h"
    … …  
    5358
    5459    /**
    55         @returns a reference to the only existing instance of the OutputHandler class.
     60        @brief Returns a reference to the only existing instance of the OutputHandler class.
     61        @return The instance
    5662    */
    5763    OutputHandler& OutputHandler::getOutStream()

  • code/branches/core/src/orxonox/core/OutputHandler.h

    r790 r813  
    2626 */
    2727
    28 /*!
     28/**
    2929    @file OutputHandler.h
    3030    @brief Definition of the OutputHandler class.
    … …  
    5959            static OutputHandler& getOutStream();
    6060
    61             /** @returns a reference to the logfile. */
     61            /** @brief Returns a reference to the logfile. @return The logfile */
    6262            inline std::ofstream& getLogfile()
    6363                { return this->logfile_; }
    … …  
    6767                { this->outputLevel_ = level; return *this; }
    6868
    69             /** @returns the level of the incoming output. */
     69            /** @brief Returns the level of the incoming output. @return The level */
    7070            inline int getOutputLevel() const
    7171                { return this->outputLevel_; }

  • code/branches/core/src/orxonox/core/SignalHandler.cc

    r790 r813  
    2525 *
    2626 */
     27
     28/**
     29    @file SignalHandler.cc
     30    @brief Implementation of the SignalHandler class.
     31*/
    2732
    2833#include <assert.h>

  • code/branches/core/src/orxonox/core/SignalHandler.h

    r790 r813  
    2626 */
    2727
    28 /*!
    29  * @file SignalHandler.h
    30  */
     28/**
     29    @file SignalHandler.h
     30    @brief Definition of the SignalHandler class.
     31*/
    3132
    3233#ifndef _SignalHandler_H__

  • code/branches/core/src/orxonox/tools/Timer.h

    r790 r813  
    9494            /** @brief Unpauses the Timer - continues with the given state. */
    9595            inline void unpauseTimer() { this->bActive_ = true; }
    96             /** @returns true if the Timer is active (= not stoped, not paused). */
     96            /** @brief Returns true if the Timer is active (= not stoped, not paused). @return True = Time is active */
    9797            inline bool isActive() const { return this->bActive_; }
    9898
Note: See TracChangeset for help on using the changeset viewer.