Changeset 817 for code/branches/core/src/orxonox/core

Timestamp:

Feb 16, 2008, 7:31:18 PM (16 years ago)

Author:

landauf

Message:

big update:

• reimplemented direct-child and direct-parent list and several related functions (get-iterator, get-list)
• reimplemented isDirectChildOf- and isDirectParentOf-functions in Identifier, SubclassIdentifier and OrxonoxClass
• renamed isDirectlyA to isExactlyA in Identifier, SubclassIdentifier and OrxonoxClass

• ClassTreeMask works now with interfaces and has more possibilities (parameters for overwriting of previous rules and cleaning after adding a new function)

• ObjectList's begin() and end() functions use ClassManager to avoid problems with libraries
• the Factory got functions to return begin() and end() iterator for the identifier-map
• overloaded << operator to put identifier-lists on the stream

Location:

code/branches/core/src/orxonox/core

Files:

• ClassTreeMask.cc (modified) (18 diffs)
• ClassTreeMask.h (modified) (7 diffs)
• Factory.cc (modified) (1 diff)
• Factory.h (modified) (1 diff)
• Identifier.cc (modified) (9 diffs)
• Identifier.h (modified) (13 diffs)
• ObjectList.h (modified) (4 diffs)
• OrxonoxClass.h (modified) (5 diffs)

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

@@ -57 +57 @@
     {
         // Go through the list of all subnodes and delete them
+        this->deleteAllSubnodes();
+    }
+
+    /**
+        @brief Sets the rule for the node to "included".
+    */
+    void ClassTreeMaskNode::include(bool overwrite)
+    {
+        this->setIncluded(true, overwrite);
+    }
+
+    /**
+        @brief Sets the rule for the node to "excluded".
+    */
+    void ClassTreeMaskNode::exclude(bool overwrite)
+    {
+        this->setIncluded(false, overwrite);
+    }
+
+    /**
+        @brief Sets the rule for the node to a given value and erases all following rules.
+        @param bIncluded The rule: included (true) or excluded (false)
+    */
+    void ClassTreeMaskNode::setIncluded(bool bIncluded, bool overwrite)
+    {
+        if (overwrite)
+            this->deleteAllSubnodes();
+
+        this->bIncluded_ = bIncluded;
+    }
+
+    /**
+        @brief Adds a new subnode to the list of subnodes.
+        @param subnode The new subnode
+    */
+    void ClassTreeMaskNode::addSubnode(ClassTreeMaskNode* subnode)
+    {
+        this->subnodes_.insert(this->subnodes_.end(), subnode);
+    }
+
+    /**
+        @brief Tells if the rule is "included" or not.
+        @return The rule: true = included, false = excluded
+    */
+    bool ClassTreeMaskNode::isIncluded() const
+    {
+        return this->bIncluded_;
+    }
+
+    /**
+        @brief Tells if the rule is "excluded" or not.
+        @return The inverted rule: true = excluded, false = included
+    */
+    bool ClassTreeMaskNode::isExcluded() const
+    {
+        return (!this->bIncluded_);
+    }
+
+    /**
+        @brief Returns the Identifier of the class the rule refers to.
+        @return The Identifier representing the class
+    */
+    const Identifier* ClassTreeMaskNode::getClass() const
+    {
+        return this->subclass_;
+    }
+
+    /**
+        @brief Deletes all subnodes of this node.
+    */
+    void ClassTreeMaskNode::deleteAllSubnodes()
+    {
+        // Go through the list of all subnodes and delete them
         for (std::list<ClassTreeMaskNode*>::iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); )
             delete (*(it++));
-    }
-
-    /**
-        @brief Sets the rule for the node to "included".
-    */
-    void ClassTreeMaskNode::include()
-    {
-        this->bIncluded_ = true;
-    }
-
-    /**
-        @brief Sets the rule for the node to "excluded".
-    */
-    void ClassTreeMaskNode::exclude()
-    {
-        this->bIncluded_ = false;
-    }
-
-    /**
-        @brief Sets the rule for the node to a given value.
-        @param bIncluded The rule: included (true) or excluded (false)
-    */
-    void ClassTreeMaskNode::setIncluded(bool bIncluded)
-    {
-        this->bIncluded_ = bIncluded;
-    }
-
-    /**
-        @brief Adds a new subnode to the list of subnodes.
-        @param subnode The new subnode
-    */
-    void ClassTreeMaskNode::addSubnode(ClassTreeMaskNode* subnode)
-    {
-        this->subnodes_.insert(this->subnodes_.end(), subnode);
-    }
-
-    /**
-        @brief Tells if the rule is "included" or not.
-        @return The rule: true = included, false = excluded
-    */
-    bool ClassTreeMaskNode::isIncluded() const
-    {
-        return this->bIncluded_;
-    }
-
-    /**
-        @brief Tells if the rule is "excluded" or not.
-        @return The inverted rule: true = excluded, false = included
-    */
-    bool ClassTreeMaskNode::isExcluded() const
-    {
-        return (!this->bIncluded_);
-    }
-
-    /**
-        @brief Returns the Identifier of the class the rule refers to.
-        @return The Identifier representing the class
-    */
-    const Identifier* ClassTreeMaskNode::getClass() const
-    {
-        return this->subclass_;
+
+        // Clear the list
+        this->subnodes_.clear();
     }
 
@@ -258 +273 @@
         this->root_ = new ClassTreeMaskNode(ClassManager<BaseObject>::getIdentifier(), true);
         for (ClassTreeMaskIterator it = other.root_; it; ++it)
-            this->add(it->getClass(), it->isIncluded());
+            this->add(it->getClass(), it->isIncluded(), false);
     }
 
@@ -273 +288 @@
         @param subclass The subclass
     */
-    void ClassTreeMask::include(const Identifier* subclass)
-    {
-        this->add(subclass, true);
+    void ClassTreeMask::include(const Identifier* subclass, bool overwrite, bool clean)
+    {
+        this->add(subclass, true, overwrite, clean);
     }
 
@@ -282 +297 @@
         @param subclass The subclass
     */
-    void ClassTreeMask::exclude(const Identifier* subclass)
-    {
-        this->add(subclass, false);
+    void ClassTreeMask::exclude(const Identifier* subclass, bool overwrite, bool clean)
+    {
+        this->add(subclass, false, overwrite, clean);
     }
 
@@ -292 +307 @@
         @param bInclude The rule: include (true) or exclude (false)
     */
-    void ClassTreeMask::add(const Identifier* subclass, bool bInclude)
-    {
+    void ClassTreeMask::add(const Identifier* subclass, bool bInclude, bool overwrite, bool clean)
+    {
+        // Check if the given subclass is a child of our root-class
         if (subclass->isA(this->root_->getClass()))
-            this->add(this->root_, subclass, bInclude);
+        {
+            // Yes it is: Just add the rule to the three
+            this->add(this->root_, subclass, bInclude, overwrite);
+        }
         else
         {
-
-        }
-
-        this->clean();
+            // No it's not: Search for classes inheriting from the given class and add the rules for them
+            for (std::list<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
+                if ((*it)->isA(this->root_->getClass()))
+                    if (overwrite || (!this->nodeExists(*it))) // If we don't want to overwrite, only add nodes that don't already exist
+                        this->add(this->root_, *it, bInclude, overwrite);
+        }
+
+        // Clean the rule-tree
+        if (clean)
+            this->clean();
     }
 
@@ -310 +335 @@
         @param bInclude The rule: include (true) or exclude (false)
     */
-    void ClassTreeMask::add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude)
+    void ClassTreeMask::add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude, bool overwrite)
     {
         // Check if the current node contains exactly the subclass we want to add
@@ -316 +341 @@
         {
             // We're at the right place, just change the mask and return
-            node->setIncluded(bInclude);
+            node->setIncluded(bInclude, overwrite);
             return;
         }
-        else
+        else if (subclass->isA(node->getClass()))
         {
             // Search for an already existing node, containing the subclass we want to add
@@ -327 +352 @@
                 {
                     // We've found an existing node -> delegate the work with a recursive function-call and return
-                    this->add(*it, subclass, bInclude);
+                    this->add(*it, subclass, bInclude, overwrite);
                     return;
                 }
@@ -335 +360 @@
             ClassTreeMaskNode* newnode = new ClassTreeMaskNode(subclass, bInclude);
 
-            // Search for nodes that should actually be subnodes of our new node
+            // Search for nodes that should actually be subnodes of our new node and erase them
             for (std::list<ClassTreeMaskNode*>::iterator it = node->subnodes_.begin(); it != node->subnodes_.end(); )
             {
                 if ((*it)->getClass()->isChildOf(subclass))
                 {
-                    // We've found a subnode: add it to the new node an erase it from the current node
-                    newnode->addSubnode(*it);
+                    // We've found a subnode: add it to the new node and erase it from the current node
+                    if (!overwrite)
+                        newnode->addSubnode(*it);
+                    else
+                        delete (*it);
+
                     node->subnodes_.erase(it++);
                 }
@@ -453 +482 @@
 
     /**
+        @brief Checks if a node for the given subclass exists.
+        @param subclass The Identifier of the subclass
+        @return True = the node exists
+    */
+    bool ClassTreeMask::nodeExists(const Identifier* subclass)
+    {
+        for (ClassTreeMaskIterator it = this->root_; it; ++it)
+            if ((*it)->getClass() == subclass)
+                return true;
+
+        return false;
+    }
+
+    /**
         @brief Assignment operator: Adds all rules of the other mask.
         @param other The other mask
@@ -467 +510 @@
         // Copy all rules from the other mask
         for (ClassTreeMaskIterator it = temp.root_; it; ++it)
-            this->add(it->getClass(), it->isIncluded());
+            this->add(it->getClass(), it->isIncluded(), false, false);
 
         // Return a reference to the mask itself
@@ -505 +548 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass), false, false);
         }
 
@@ -512 +555 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) or other.isIncluded(subclass), false, false);
         }
 
@@ -536 +579 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass), false, false);
         }
 
@@ -543 +586 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) and other.isIncluded(subclass), false, false);
         }
 
@@ -576 +619 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, !this->isIncluded(subclass));
+            newmask.add(subclass, !this->isIncluded(subclass), false, false);
         }
 
@@ -650 +693 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass), false, false);
         }
 
@@ -657 +700 @@
         {
             const Identifier* subclass = it->getClass();
-            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass));
+            newmask.add(subclass, this->isIncluded(subclass) xor other.isIncluded(subclass), false, false);
         }
 

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

@@ -34 +34 @@
     Identifier of the class.
 
-    You can work with a ClassTreeMask in the sense of the set theory, meaning that you can create
+    You can work with a ClassTreeMask in the sense of the set-theory, meaning that you can create
     unions, intersections, complements and differences by using overloaded operators.
+
+
 
     The ClassTreeMask is internally represented by a tree. The nodes in the tree are
@@ -42 +44 @@
     nodes changing the mask. By adding new rules, the tree gets reordered dynamically.
 
-    You can manually add useless rules and they stay in the tree. That way you can add rules in
-    any order without changing information of the resulting mask. Example: A new mask includes all
-    classes. Now you explicitly include a subclass. This seems to be useless. But if you exclude a
-    baseclass of the formerly included subclass, the subclass stays included. You could create the
-    same mask by first excluding the baseclass and then including the subclass. You can drop
-    useless rules from the tree by calling clean().
+    Adding a new rule overwrites all rules assigned to inherited classes. Use overwrite = false
+    if you don't like this feature. Useless rules that don't change the information of the mask
+    aren't saved in the internal tree. Use clean = false if you wan't to save them.
+
+    With overwrite = false and clean = false it doesn't matter in which way you create the mask.
+    You can manually drop useless rules from the tree by calling clean().
+
+
 
     Because of the complicated shape of the internal tree, there is an iterator to iterate
@@ -91 +95 @@
             ~ClassTreeMaskNode();
 
-            void include();
-            void exclude();
-            void setIncluded(bool bIncluded);
+            void include(bool overwrite = true);
+            void exclude(bool overwrite = true);
+            void setIncluded(bool bIncluded, bool overwrite = true);
 
             void addSubnode(ClassTreeMaskNode* subnode);
@@ -103 +107 @@
 
         private:
+            void deleteAllSubnodes();
+
             const Identifier* subclass_;                //!< The Identifier of the subclass the rule refers to
             bool bIncluded_;                            //!< The rule: included or excluded
@@ -146 +152 @@
         With a ClassTreeMask, you can include or exclude subtrees of the class-tree, starting
         with a given subclass, described by the corresponding Identifier. To minimize the size
-        of the mask, the mask saves only relevant rules. But you are allowed to manually add
-        rules that don't change the information of the mask. This way you can create the same
-        mask by adding the same rules in a different way without changing the information. If
-        you want to drop useless rules, call the clean() function.
+        of the mask, the mask saves only relevant rules. But you can manually add rules that
+        don't change the information of the mask by using clean = false. If you want to drop
+        useless rules, call the clean() function.
     */
     class _CoreExport ClassTreeMask
@@ -158 +163 @@
             ~ClassTreeMask();
 
-            void include(const Identifier* subclass);
-            void exclude(const Identifier* subclass);
-            void add(const Identifier* subclass, bool bInclude);
+            void include(const Identifier* subclass, bool overwrite = true, bool clean = true);
+            void exclude(const Identifier* subclass, bool overwrite = true, bool clean = true);
+            void add(const Identifier* subclass, bool bInclude, bool overwrite = true, bool clean = true);
             void reset();
             void clean();
@@ -193 +198 @@
 
         private:
-            void add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude);
+            void add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude, bool overwrite = true);
             bool isIncluded(ClassTreeMaskNode* node, const Identifier* subclass) const;
             void clean(ClassTreeMaskNode* node);
+            bool nodeExists(const Identifier* subclass);
 
             ClassTreeMaskNode* root_;   //!< The root-node of the internal rule-tree, usually BaseObject

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

@@ -109 +109 @@
       return &theOneAndOnlyFactoryInstance;
     }
+
+    /**
+        @brief Returns the begin-iterator of the factory-map.
+        @return The begin-iterator
+    */
+    std::map<std::string, Identifier*>::const_iterator Factory::getFactoryBegin()
+    {
+        return Factory::getFactoryPointer()->identifierStringMap_.begin();
+    }
+
+    /**
+        @brief Returns the end-iterator of the factory-map.
+        @return The end-iterator
+    */
+    std::map<std::string, Identifier*>::const_iterator Factory::getFactoryEnd()
+    {
+        return Factory::getFactoryPointer()->identifierStringMap_.end();
+    }
 }

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

@@ -67 +67 @@
 
             static Factory* getFactoryPointer();    // avoid overriding order problem in the static intialisation process
+            static std::map<std::string, Identifier*>::const_iterator getFactoryBegin();
+            static std::map<std::string, Identifier*>::const_iterator getFactoryEnd();
 
         private:

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

@@ -30 +30 @@
     @brief Implementation of the Identifier class.
 */
+
+#include <ostream>
 
 #include "Identifier.h"
@@ -50 +52 @@
 
         this->children_ = new std::list<const Identifier*>();
+        this->directChildren_ = new std::list<const Identifier*>();
 
         // Use a static variable because the classID gets created before main() and that's why we should avoid static member variables
@@ -62 +65 @@
     {
         delete this->children_;
+        delete this->directChildren_;
     }
 
@@ -75 +79 @@
         if (parents)
         {
-            std::list<const Identifier*>::iterator temp1 = parents->begin();
-            while (temp1 != parents->end())
+            this->parents_ = (*parents);
+            this->directParents_ = (*parents);
+
+            // Iterate through all parents
+            for (std::list<const Identifier*>::iterator it = parents->begin(); it != parents->end(); ++it)
             {
-                this->parents_.insert(this->parents_.end(), *temp1);
-                (*temp1)->getChildren().insert((*temp1)->getChildren().end(), this); // We're a child of our parents
-
-                ++temp1;
+                // Tell the parent we're one of it's children
+                (*it)->getChildrenIntern().insert((*it)->getChildrenIntern().end(), this);
+
+                // Erase all parents of our parent from our direct-parent-list
+                for (std::list<const Identifier*>::const_iterator it1 = (*it)->getParents().begin(); it1 != (*it)->getParents().end(); ++it1)
+                {
+                    // Search for the parent's parent in our direct-parent-list
+                    for (std::list<const Identifier*>::iterator it2 = this->directParents_.begin(); it2 != this->directParents_.end(); ++it2)
+                    {
+                        if ((*it1) == (*it2))
+                        {
+                            // We've found a non-direct parent in our list: Erase it
+                            this->directParents_.erase(it2);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Now iterate through all direct parents
+            for (std::list<const Identifier*>::iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+            {
+                // Tell the parent we're one of it's direct children
+                (*it)->getDirectChildrenIntern().insert((*it)->getDirectChildrenIntern().end(), this);
             }
         }
@@ -98 +125 @@
         else
         {
-            // Abstract classes don't have a factory and therefore can't create new objects
             COUT(1) << "An error occurred in Identifier:" << std::endl;
-            COUT(1) << "Error: Cannot create an object of type '" << this->name_ << "'. Class is abstract." << std::endl;
+            COUT(1) << "Error: Cannot fabricate an object of type '" << this->name_ << "'. Class has no factory." << std::endl;
             COUT(1) << "Aborting..." << std::endl;
             abort();
@@ -130 +156 @@
         @param identifier The identifier to compare with
     */
-    bool Identifier::isDirectlyA(const Identifier* identifier) const
+    bool Identifier::isExactlyA(const Identifier* identifier) const
     {
         return (identifier == this);
@@ -145 +171 @@
 
     /**
+        @brief Returns true, if the assigned identifier is a direct child of the given identifier.
+        @param identifier The identifier to compare with
+    */
+    bool Identifier::isDirectChildOf(const Identifier* identifier) const
+    {
+        return this->identifierIsInList(identifier, this->directParents_);
+    }
+
+    /**
         @brief Returns true, if the assigned identifier is a parent of the given identifier.
         @param identifier The identifier to compare with
@@ -151 +186 @@
     {
         return this->identifierIsInList(identifier, *this->children_);
+    }
+
+    /**
+        @brief Returns true, if the assigned identifier is a direct parent of the given identifier.
+        @param identifier The identifier to compare with
+    */
+    bool Identifier::isDirectParentOf(const Identifier* identifier) const
+    {
+        return this->identifierIsInList(identifier, *this->directChildren_);
     }
 
@@ -167 +211 @@
         return false;
     }
+
+    std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list)
+    {
+        for (std::list<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
+            out << (*it)->getName() << " ";
+
+        return out;
+    }
 }

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

@@ -39 +39 @@
 
     Every object has a pointer to the Identifier of its class. This allows the use isA(...),
-    isDirectlyA(...), isChildOf(...) and isParentOf(...).
+    isExactlyA(...), isChildOf(...) and isParentOf(...).
 
     To create the class-hierarchy, the Identifier has some intern functions and variables.
@@ -82 +82 @@
 
         Every object has a pointer to the Identifier of its class. This allows the use isA(...),
-        isDirectlyA(...), isChildOf(...) and isParentOf(...).
+        isExactlyA(...), isChildOf(...) and isParentOf(...).
 
         You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
@@ -102 +102 @@
             BaseObject* fabricate();
             bool isA(const Identifier* identifier) const;
-            bool isDirectlyA(const Identifier* identifier) const;
+            bool isExactlyA(const Identifier* identifier) const;
             bool isChildOf(const Identifier* identifier) const;
+            bool isDirectChildOf(const Identifier* identifier) const;
             bool isParentOf(const Identifier* identifier) const;
+            bool isDirectParentOf(const Identifier* identifier) const;
 
             /** @brief Removes all objects of the corresponding class. */
@@ -114 +116 @@
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
             inline const std::list<const Identifier*>& getParents() const { return this->parents_; }
-
             /** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
-
             /** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
             inline std::list<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
 
+            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
+            inline const std::list<const Identifier*>& getChildren() const { return (*this->children_); }
             /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
-
             /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
             inline std::list<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
+
+            /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
+            inline const std::list<const Identifier*>& getDirectParents() const { return this->directParents_; }
+            /** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
+            /** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
+
+            /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
+            inline const std::list<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
+            /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
+            /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
 
             /** @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 */
@@ -143 +158 @@
             inline void setConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
                 { this->configValues_[varname] = container; }
+
+            static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
 
         private:
@@ -150 +167 @@
             void initialize(std::list<const Identifier*>* parents);
 
-            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
-            inline std::list<const Identifier*>& getParents() { return this->parents_; }
-
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
-            inline std::list<const Identifier*>& getChildren() const { return (*this->children_); }
+            inline std::list<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
+            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
+            inline std::list<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
 
             /**
@@ -174 +190 @@
             }
 
-            static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
-
-            std::list<const Identifier*> parents_;                      //!< The Parents of the class the Identifier belongs to
-            std::list<const Identifier*>* children_;                    //!< The Children of the class the Identifier belongs to
+            std::list<const Identifier*> parents_;                      //!< The parents of the class the Identifier belongs to
+            std::list<const Identifier*>* children_;                    //!< The children of the class the Identifier belongs to
+
+            std::list<const Identifier*> directParents_;                //!< The direct parents of the class the Identifier belongs to
+            std::list<const Identifier*>* directChildren_;              //!< The direct children of the class the Identifier belongs to
 
             std::string name_;                                          //!< The name of the class the Identifier belongs to
@@ -188 +205 @@
     };
 
+    std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list);
+
 
     // ###############################
@@ -215 +234 @@
             void removeObjects() const;
             void setName(const std::string& name);
+            inline const ObjectList<T>* getObjects() const { return this->objects_; }
 
         private:
@@ -231 +251 @@
     ClassIdentifier<T>::ClassIdentifier()
     {
-        this->objects_ = ObjectList<T>::getList();
+//        this->objects_ = ObjectList<T>::getList();
+        this->objects_ = new ObjectList<T>();
         this->bSetName_ = false;
     }
@@ -294 +315 @@
     void ClassIdentifier<T>::removeObjects() const
     {
-        for (Iterator<T> it = ObjectList<T>::start(); it;)
+        for (Iterator<T> it = this->objects_->start(); it;)
             delete *(it++);
     }
+
 
     // ###############################
@@ -409 +431 @@
 
             /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
-            inline bool isDirectlyA(const Identifier* identifier) const
-                { return this->identifier_->isDirectlyA(identifier); }
+            inline bool isExactlyA(const Identifier* identifier) const
+                { return this->identifier_->isExactlyA(identifier); }
 
             /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
@@ -416 +438 @@
                 { return this->identifier_->isChildOf(identifier); }
 
+            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
+            inline bool isDirectChildOf(const Identifier* identifier) const
+                { return this->identifier_->isDirectChildOf(identifier); }
+
             /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
             inline bool isParentOf(const Identifier* identifier) const
                 { return this->identifier_->isParentOf(identifier); }
+
+            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
+            inline bool isDirectParentOf(const Identifier* identifier) const
+                { return this->identifier_->isDirectParentOf(identifier); }
 
         private:

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

@@ -40 +40 @@
 #include "CorePrereqs.h"
 #include "Iterator.h"
+#include "ClassManager.h"
 
 namespace orxonox
@@ -83 +84 @@
     {
         public:
-            static ObjectList<T>* getList();
+            ObjectList();
+            ~ObjectList();
 
             ObjectListElement<T>* add(T* object);
@@ -90 +92 @@
             /** @brief Returns the first element in the list. @return The first element */
             inline static Iterator<T> start()
-                { return Iterator<T>(getList()->first_); }
+                { return Iterator<T>(ClassManager<T>::getIdentifier()->getObjects()->first_); }
 
             /** @brief Returns the first element in the list. @return The first element */
             inline static Iterator<T> begin()
-                { return Iterator<T>(getList()->first_); }
+                { return Iterator<T>(ClassManager<T>::getIdentifier()->getObjects()->first_); }
 
             /** @brief Returns the last element in the list. @return The last element */
             inline static Iterator<T> end()
-                { return Iterator<T>(getList()->last_); }
+                { return Iterator<T>(ClassManager<T>::getIdentifier()->getObjects()->last_); }
 
             ObjectListElement<T>* first_;       //!< The first element in the list
             ObjectListElement<T>* last_;        //!< The last element in the list
-
-        private:
-            ObjectList();
-            ~ObjectList();
     };
 
@@ -131 +129 @@
             this->first_ = temp;
         }
-    }
-
-    /**
-        @brief Returns a pointer to the only existing instance for the given class T. @return The instance
-    */
-    template <class T>
-    ObjectList<T>* ObjectList<T>::getList()
-    {
-        static ObjectList<T> theOnlyObjectListObjectForClassT = ObjectList<T>();
-        return &theOnlyObjectListObjectForClassT;
     }
 

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

@@ -72 +72 @@
             inline void createParents() { this->parents_ = new std::list<const Identifier*>(); }
 
-//            /** @brief Sets the Parents of the object. Used by the RegisterObject-macro. */
-//            inline void setParents(std::list<const Identifier*>* parents) { this->parents_ = parents; }
-
             /** @brief Returns the MetaObjectList of the object, containing a link to all ObjectLists and ObjectListElements the object is registered in. @return The list */
             inline MetaObjectList& getMetaList() { return this->metaList_; }
@@ -83 +80 @@
                 { return this->getIdentifier()->isA(identifier); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const Identifier* identifier)
-                { return this->getIdentifier()->isDirectlyA(identifier); }
+            inline bool isExactlyA(const Identifier* identifier)
+                { return this->getIdentifier()->isExactlyA(identifier); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const Identifier* identifier)
                 { return this->getIdentifier()->isChildOf(identifier); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const Identifier* identifier)
+                { return this->getIdentifier()->isDirectChildOf(identifier); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const Identifier* identifier)
                 { return this->getIdentifier()->isParentOf(identifier); }
+            /** @brief Returns true if the objects class is a direct parent of the given type. */
+            inline bool isDirectParentOf(const Identifier* identifier)
+                { return this->getIdentifier()->isDirectParentOf(identifier); }
 
 
@@ -97 +100 @@
                 { return this->getIdentifier()->isA(identifier->getIdentifier()); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const SubclassIdentifier<class B>* identifier)
-                { return this->getIdentifier()->isDirectlyA(identifier->getIdentifier()); }
+            inline bool isExactlyA(const SubclassIdentifier<class B>* identifier)
+                { return this->getIdentifier()->isExactlyA(identifier->getIdentifier()); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const SubclassIdentifier<class B>* identifier)
+                { return this->getIdentifier()->isDirectChildOf(identifier->getIdentifier()); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const SubclassIdentifier<class B>* identifier)
                 { return this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct parent of the given type. */
+            inline bool isDirectParentOf(const SubclassIdentifier<class B>* identifier)
+                { return this->getIdentifier()->isDirectParentOf(identifier->getIdentifier()); }
 
 
@@ -111 +120 @@
                 { return this->getIdentifier()->isA(identifier.getIdentifier()); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const SubclassIdentifier<class B> identifier)
-                { return this->getIdentifier()->isDirectlyA(identifier.getIdentifier()); }
+            inline bool isExactlyA(const SubclassIdentifier<class B> identifier)
+                { return this->getIdentifier()->isExactlyA(identifier.getIdentifier()); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const SubclassIdentifier<class B> identifier)
+                { return this->getIdentifier()->isDirectChildOf(identifier.getIdentifier()); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const SubclassIdentifier<class B> identifier)
                 { return this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct parent of the given type. */
+            inline bool isDirectParentOf(const SubclassIdentifier<class B> identifier)
+                { return this->getIdentifier()->isDirectParentOf(identifier.getIdentifier()); }
 
 
@@ -125 +140 @@
                 { return this->getIdentifier()->isA(object->getIdentifier()); }
             /** @brief Returns true if the objects class is exactly of the given type. */
-            inline bool isDirectlyA(const OrxonoxClass* object)
-                { return this->getIdentifier()->isDirectlyA(object->getIdentifier()); }
+            inline bool isExactlyA(const OrxonoxClass* object)
+                { return this->getIdentifier()->isExactlyA(object->getIdentifier()); }
             /** @brief Returns true if the objects class is a child of the given type. */
             inline bool isChildOf(const OrxonoxClass* object)
                 { return this->getIdentifier()->isChildOf(object->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectChildOf(const OrxonoxClass* object)
+                { return this->getIdentifier()->isDirectChildOf(object->getIdentifier()); }
             /** @brief Returns true if the objects class is a parent of the given type. */
             inline bool isParentOf(const OrxonoxClass* object)
                 { return this->getIdentifier()->isParentOf(object->getIdentifier()); }
+            /** @brief Returns true if the objects class is a direct child of the given type. */
+            inline bool isDirectParentOf(const OrxonoxClass* object)
+                { return this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }