Changeset 901 for code/branches/core2/src/orxonox/core

Timestamp:

Mar 19, 2008, 12:38:32 AM (17 years ago)

Author:

landauf

Message:

Namespaces are working now. I love this feature, can't stop playing with it

Location:

code/branches/core2/src/orxonox/core

Files:

• Loader.cc (modified) (2 diffs)
• Namespace.cc (modified) (4 diffs)
• Namespace.h (modified) (1 diff)
• NamespaceNode.cc (modified) (6 diffs)
• NamespaceNode.h (modified) (1 diff)
• XMLPort.h (modified) (1 diff)

code/branches/core2/src/orxonox/core/Loader.cc

@@ -115 +115 @@
             ticpp::Document xmlfile(level->getFile());
             xmlfile.LoadFile();
+
             ticpp::Element rootElement;
             rootElement.SetAttribute("name", "root");
+            rootElement.SetAttribute("bAutogenerated", true);
 
             for (ticpp::Iterator<ticpp::Element> child = xmlfile.FirstChildElement(false); child != child.end(); child++)
@@ -126 +128 @@
             rootNamespace->setLevel(level);
             rootNamespace->setNamespace(rootNamespace);
-            rootNamespace->deleteNamespaceNodesAfterDestruction(true);
+            rootNamespace->setRoot(true);
             rootNamespace->XMLPort(rootElement, true);
 
             COUT(0) << "Finished loading " << level->getFile() << "." << std::endl;
+
+            COUT(4) << "Namespace-tree:" << std::endl << rootNamespace->toString("  ") << std::endl;
 
             return true;

code/branches/core2/src/orxonox/core/Namespace.cc

@@ -41 +41 @@
 
         this->bAutogeneratedFileRootNamespace_ = false;
-        this->bDeleteNamespaceNodesAfterDestruction_ = false;
+        this->bRoot_ = false;
         this->operator_ = "or";
     }
@@ -47 +47 @@
     Namespace::~Namespace()
     {
-        if (this->bDeleteNamespaceNodesAfterDestruction_)
+        if (this->bRoot_)
             for (std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it)
                 delete (*it);
@@ -73 +73 @@
             name.replace(pos, 1, " ");
         SubString tokens(name, " ", "", false, '\\', '"', '\0', '\0', '\0');
-        for (unsigned int i = 0; i < tokens.size(); i++)
+        if (this->bRoot_)
         {
-            for (std::set<NamespaceNode*>::iterator it = this->getNamespace()->representingNamespaces_.begin(); it != this->getNamespace()->representingNamespaces_.end(); ++it)
+            this->representingNamespaces_.insert(new NamespaceNode(this->getName()));
+        }
+        else
+        {
+            for (unsigned int i = 0; i < tokens.size(); i++)
             {
-                std::set<NamespaceNode*> temp = (*it)->getNodeRelative(tokens[i]);
-                this->representingNamespaces_.insert(temp.begin(), temp.end());
+                for (std::set<NamespaceNode*>::iterator it = this->getNamespace()->representingNamespaces_.begin(); it != this->getNamespace()->representingNamespaces_.end(); ++it)
+                {
+                    std::set<NamespaceNode*> temp = (*it)->getNodeRelative(tokens[i]);
+                    this->representingNamespaces_.insert(temp.begin(), temp.end());
+                }
             }
         }
@@ -138 +145 @@
         return false;
     }
+
+    std::string Namespace::toString() const
+    {
+        std::string output;
+
+        int i = 0;
+        for (std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it)
+        {
+            if (i > 0)
+                output += " / ";
+
+            output += (*it)->toString();
+        }
+
+        return output;
+    }
+
+    std::string Namespace::toString(const std::string& indentation) const
+    {
+        std::string output;
+
+        int i = 0;
+        for (std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it)
+        {
+            if (i > 0)
+                output += "\n";
+
+            output += (*it)->toString(indentation);
+        }
+
+        return output;
+    }
 }

code/branches/core2/src/orxonox/core/Namespace.h

@@ -59 +59 @@
                 { return this->operator_; }
 
+            void setRoot(bool bRoot)
+                { this->bRoot_ = bRoot; }
+
             bool includes(const Namespace* ns) const;
             bool isIncludedIn(const Namespace* ns) const { return ns->includes(this); }
 
-            void deleteNamespaceNodesAfterDestruction(bool bDelete)
-                { this->bDeleteNamespaceNodesAfterDestruction_ = bDelete; }
+            std::string toString() const;
+            std::string toString(const std::string& indentation) const;
 
         private:
             std::set<NamespaceNode*> representingNamespaces_;
             bool bAutogeneratedFileRootNamespace_;
-            bool bDeleteNamespaceNodesAfterDestruction_;
+            bool bRoot_;
             std::string operator_;
     };

code/branches/core2/src/orxonox/core/NamespaceNode.cc

@@ -49 +49 @@
         std::set<NamespaceNode*> nodes;
 
-        if (name == "")
+        if ((name.size() == 0) || (name == ""))
         {
             nodes.insert(this);
@@ -56 +56 @@
         {
             unsigned int pos = name.find("::");
-            std::string firstPart = name.substr(0, pos);
-            std::string secondPart = name.substr(pos + 2, std::string::npos);
+            std::string firstPart = name;
+            std::string secondPart;
+
+            if (pos != std::string::npos)
+            {
+                firstPart = name.substr(0, pos);
+                secondPart = name.substr(pos + 2, std::string::npos);
+            }
 
             if (firstPart == "..")
@@ -64 +70 @@
                 {
                     COUT(2) << "Warning: Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", namespace is root." << std::endl;
+                    nodes = this->getNodeRelative(secondPart);
+                }
+                else if (!this->parent_)
+                {
+                    COUT(2) << "Warning: Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", no parent namespace set." << std::endl;
                     nodes = this->getNodeRelative(secondPart);
                 }
@@ -78 +89 @@
 
                 if ((*it).second->isHidden())
+                {
                     COUT(2) << "Warning: Subnamespace '" << firstPart << "' in namespace '" << this->name_ << "' is hidden and can't be accessed." << std::endl;
+                    nodes.insert(this);
+                }
                 else
+                {
                     nodes = (*it).second->getNodeRelative(secondPart);
+                }
             }
             else
             {
+                bool bFoundMatchingNamespace = false;
+
                 for (std::map<std::string, NamespaceNode*>::iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
                 {
@@ -90 +108 @@
                         std::set<NamespaceNode*> temp2 = (*it).second->getNodeRelative(secondPart);
                         nodes.insert(temp2.begin(), temp2.end());
+                        bFoundMatchingNamespace = true;
                     }
+                }
+
+                if (!bFoundMatchingNamespace)
+                {
+                    COUT(2) << "Warning: No file included with name '" << firstPart.substr(1, std::string::npos) << "' at this part of the level file, using parent namespace instead." << std::endl;
+                    nodes = this->getNodeRelative(secondPart);
                 }
             }
@@ -113 +138 @@
         return false;
     }
+
+    std::string NamespaceNode::toString() const
+    {
+        std::string output = this->name_;
+
+        if (this->subnodes_.size() > 0)
+        {
+            output += " (";
+
+            int i = 0;
+            for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); i++, ++it)
+            {
+                if (i > 0)
+                    output += ", ";
+
+                output += (*it).second->toString();
+            }
+
+            output += ")";
+        }
+
+        return output;
+    }
+
+    std::string NamespaceNode::toString(const std::string& indentation) const
+    {
+        std::string output = (indentation + this->name_ + "\n");
+
+        for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
+            output += (*it).second->toString(indentation + "  ");
+
+        return output;
+    }
 }

code/branches/core2/src/orxonox/core/NamespaceNode.h

@@ -53 +53 @@
             bool includes(const NamespaceNode*) const;
 
+            std::string toString() const;
+            std::string toString(const std::string& indentation) const;
+
         private:
             std::string name_;

code/branches/core2/src/orxonox/core/XMLPort.h

@@ -256 +256 @@
                                             newObject->setNamespace(object->getNamespace());
                                             if (this->bLoadBefore_)
+                                            {
                                                 newObject->XMLPort(*child, true);
-                                            COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->classname_ << " (objectname " << object->getName() << ")" << std::endl;
+                                                COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->classname_ << " (objectname " << object->getName() << ")" << std::endl;
+                                            }
+                                            else
+                                            {
+                                                COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->classname_ << " (objectname " << object->getName() << ")" << std::endl;
+                                            }
                                             (*object.*this->loadfunction_)(newObject);
                                             if (!this->bLoadBefore_)