Changeset 871 for code/trunk/src/orxonox/core/Identifier.cc

Timestamp:

Mar 9, 2008, 4:44:36 PM (16 years ago)

Author:

landauf

Message:

merged core branch to trunk

File:

• code/trunk/src/orxonox/core/Identifier.cc (modified) (6 diffs)

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

@@ -26 +26 @@
  */
 
-/*!
+/**
     @file Identifier.cc
     @brief Implementation of the Identifier class.
 */
+
+#include <ostream>
 
 #include "Identifier.h"
@@ -49 +51 @@
         this->factory_ = 0;
 
-        this->children_ = new IdentifierList;
+        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
@@ -57 +60 @@
 
     /**
-        @brief Destructor: Deletes the IdentifierList containing the children.
+        @brief Destructor: Deletes the list containing the children.
     */
     Identifier::~Identifier()
     {
         delete this->children_;
-    }
-
-    /**
-        @brief Initializes the Identifier with an IdentifierList containing all parents of the class the Identifier belongs to.
-        @param parents The IdentifierList containing all parents
-    */
-    void Identifier::initialize(const IdentifierList* parents)
-    {
-        COUT(4) << "*** Initialize " << this->name_ << "-Singleton." << std::endl;
+        delete this->directChildren_;
+    }
+
+    /**
+        @brief Initializes the Identifier with a list containing all parents of the class the Identifier belongs to.
+        @param parents A list containing all parents
+    */
+    void Identifier::initialize(std::list<const Identifier*>* parents)
+    {
+        COUT(4) << "*** Identifier: Initialize " << this->name_ << "-Singleton." << std::endl;
         this->bCreatedOneObject_ = true;
 
         if (parents)
         {
-            IdentifierListElement* temp1 = parents->first_;
-            while (temp1)
+            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_.add(temp1->identifier_);
-                temp1->identifier_->getChildren().add(this); // We're a child of our parents
-
-                temp1 = temp1->next_;
+                // 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) << "Error: Cannot create an object of type '" << this->name_ << "'. Class is abstract." << std::endl;
+            COUT(1) << "An error occurred in Identifier.cc:" << 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();
@@ -117 +144 @@
 
     /**
-        @returns a reference to the Identifier map, containing all Identifiers.
-    */
-    std::map<std::string, Identifier*>& Identifier::getIdentifierMap()
-    {
-        static std::map<std::string, Identifier*> identifierMapStaticReference = std::map<std::string, Identifier*>();
-        return identifierMapStaticReference;
-    }
-
-    /**
-        @returns true, if the Identifier is at least of the given type.
+        @brief Returns true, if the Identifier is at least of the given type.
         @param identifier The identifier to compare with
     */
     bool Identifier::isA(const Identifier* identifier) const
     {
-        return (identifier == this || this->parents_.isInList(identifier));
-    }
-
-    /**
-        @returns true, if the Identifier is exactly of the given type.
-        @param identifier The identifier to compare with
-    */
-    bool Identifier::isDirectlyA(const Identifier* identifier) const
+        return (identifier == this || this->identifierIsInList(identifier, this->parents_));
+    }
+
+    /**
+        @brief Returns true, if the Identifier is exactly of the given type.
+        @param identifier The identifier to compare with
+    */
+    bool Identifier::isExactlyA(const Identifier* identifier) const
     {
         return (identifier == this);
@@ -144 +162 @@
 
     /**
-        @returns true, if the assigned identifier is a child of the given identifier.
+        @brief Returns true, if the assigned identifier is a child of the given identifier.
         @param identifier The identifier to compare with
     */
     bool Identifier::isChildOf(const Identifier* identifier) const
     {
-        return this->parents_.isInList(identifier);
-    }
-
-    /**
-        @returns true, if the assigned identifier is a parent of the given identifier.
+        return this->identifierIsInList(identifier, this->parents_);
+    }
+
+    /**
+        @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
     */
     bool Identifier::isParentOf(const Identifier* identifier) const
     {
-        return this->children_->isInList(identifier);
+        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_);
+    }
+
+    /**
+        @brief Returns the ConfigValueContainer of a variable, given by the string of its name.
+        @param varname The name of the variable
+        @return The ConfigValueContainer
+    */
+    ConfigValueContainer* Identifier::getConfigValueContainer(const std::string& varname)
+    {
+        std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_.find(varname);
+        if (it != configValues_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds the ConfigValueContainer of a variable, given by the string of its name.
+        @param varname The name of the variablee
+        @param container The container
+    */
+    void Identifier::addConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
+    {
+        this->configValues_[varname] = container;
+    }
+
+    /**
+        @brief Searches for a given identifier in a list and returns whether the identifier is in the list or not.
+        @param identifier The identifier to look for
+        @param list The list
+        @return True = the identifier is in the list
+    */
+    bool Identifier::identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list)
+    {
+        for (std::list<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
+            if (identifier == (*it))
+                return true;
+
+        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;
     }
 }