Changeset 895

Timestamp:

Mar 17, 2008, 1:33:00 AM (17 years ago)

Author:

landauf

Message:

• added new XMLPortParam template to specify the template arguments / to specify the functor

• implemented the Namespace object and
• added a NamespaceNode class that helps keeping track of the existing namespaces in a level

this is not yet tested nor fully included in the loader nor usefull (as we have no scripts at the moment), but i think it's a good start.

Location:

code/branches/core2/src/orxonox/core

Files:

• CMakeLists.txt (modified) (1 diff)
• CorePrereqs.h (modified) (1 diff)
• Namespace.cc (modified) (5 diffs)
• Namespace.h (modified) (1 diff)
• NamespaceNode.cc (added)
• NamespaceNode.h (added)
• XMLPort.h (modified) (1 diff)

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

@@ -18 +18 @@
   XMLPort.cc
   Namespace.cc
+  NamespaceNode.cc
 )
 

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

@@ -96 +96 @@
   class MetaObjectListElement;
   class Namespace;
+  class NamespaceNode;
   template <class T>
   class ObjectList;

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

@@ -29 +29 @@
 #include "CoreIncludes.h"
 #include "XMLPort.h"
+#include "util/SubString.h"
+#include "NamespaceNode.h"
 
 namespace orxonox
@@ -38 +40 @@
         RegisterObject(Namespace);
 
-        this->representingNamespace_ = this;
+        this->bAutogeneratedFileRootNamespace_ = false;
+        this->operator_ = "or";
     }
 
@@ -55 +58 @@
         BaseObject::XMLPort(xmlelement, loading);
 
+        std::string name = this->getName();
+        unsigned int pos = 0;
+        while ((pos = name.find(',')) != std::string::npos)
+            name.replace(pos, 1, " ");
+        while ((pos = name.find(';')) != std::string::npos)
+            name.replace(pos, 1, " ");
+        while ((pos = name.find('\n')) != std::string::npos)
+            name.replace(pos, 1, " ");
+        while ((pos = name.find('\t')) != std::string::npos)
+            name.replace(pos, 1, " ");
+        SubString tokens(name, " ", '\0', false, '\\', '"', '\0', '\0', '\0');
+        for (unsigned int i = 0; i < tokens.size(); i++)
+        {
+            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());
+            }
+        }
+
+        XMLPortParam(Namespace, "operator", setOperator, getOperator, xmlelement, loading);
+        XMLPortParam(Namespace, "bAutogenerated", setAutogenerated, isAutogenerated, xmlelement, loading);
+
+        if (this->bAutogeneratedFileRootNamespace_)
+        {
+            for (std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it)
+            {
+                (*it)->setRoot(true);
+                (*it)->setHidden(true);
+            }
+        }
+
         XMLPortObject(Namespace, BaseObject, "", loadObjects, saveObjects, xmlelement, loading, true, false);
     }
@@ -60 +95 @@
     void Namespace::loadObjects(BaseObject* object)
     {
-        object->setNamespace(this->representingNamespace_);
-
-        if (object->isA(Class(Namespace)))
-            this->addSubnamespace((Namespace*)object);
-    }
-
-    void Namespace::addSubnamespace(Namespace* ns)
-    {
-        std::string name = ns->getName().substr(ns->getName().find("::"
-
-        if (!this->hasSubnamespace(ns->getName()))
-            this->namespaces_[ns->getName()] = ns;
-        else
-            ns->representingNamespace_ = object;
-    }
-
-    bool Namespace::hasSubnamespace(const std::string& name) const
-    {
-        return (this->namespaces_.find(name) != this->namespaces_.end());
+        object->setNamespace(this);
     }
 
@@ -85 +102 @@
         return 0; // todo
     }
+
+    bool Namespace::includes(const Namespace* ns) const
+    {
+        for (std::set<NamespaceNode*>::const_iterator it1 = this->representingNamespaces_.begin(); it1 != this->representingNamespaces_.end(); ++it1)
+        {
+            for (std::set<NamespaceNode*>::const_iterator it2 = ns->representingNamespaces_.begin(); it2 != ns->representingNamespaces_.end(); ++it2)
+            {
+                if ((*it1)->includes(*it2))
+                {
+                    if (this->operator_ == "or")
+                        return true;
+
+                    if (this->operator_ == "not")
+                        return false;
+                }
+                else
+                {
+                    if (this->operator_ == "and")
+                        return false;
+                }
+            }
+        }
+
+        if (this->operator_ == "or")
+            return false;
+        else if (this->operator_ == "and")
+            return true;
+        else if (this->operator_ == "not")
+            return true;
+
+        return false;
+    }
 }

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

@@ -49 +49 @@
             const BaseObject* saveObjects(unsigned int index) const;
 
-            void addSubnamespace(Namespace* ns);
-            bool hasSubnamespace(const std::string& name) const;
+            void setAutogenerated(bool bAutogenerated)
+                { this->bAutogeneratedFileRootNamespace_ = bAutogenerated; }
+            bool isAutogenerated() const
+                { return this->bAutogeneratedFileRootNamespace_; }
+
+            void setOperator(const std::string& op)
+                { this->operator_ = op; }
+            const std::string& getOperator() const
+                { return this->operator_; }
+
+            bool includes(const Namespace* ns) const;
+            bool isIncludedIn(const Namespace* ns) const { return ns->includes(this); }
 
         private:
-            std::map<std::string, Namespace*> namespaces_;
-            Namespace* representingNamespace_;
+            std::set<NamespaceNode*> representingNamespaces_;
+            bool bAutogeneratedFileRootNamespace_;
+            std::string operator_;
     };
 }

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

@@ -42 +42 @@
 
 #define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, loading) \
-    orxonox::XMLPortClassParamContainer<classname>* xmlcontainer##loadfunction##savefunction = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
-    if (!xmlcontainer##loadfunction##savefunction) \
+    XMLPortParamGeneric(classname, paramname, xmlcontainer##loadfunction##savefunction, createFunctor(&classname::loadfunction), createFunctor(&classname::savefunction), xmlelement, loading)
+#define XMLPortParam_Template(classname, paramname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, loading) \
+    XMLPortParamGeneric(classname, paramname, xmlcontainer##loadfunction##savefunction, createFunctor loadtemplate (&classname::loadfunction), createFunctor savetemplate (&classname::savefunction), xmlelement, loading)
+
+
+#define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, loading) \
+    XMLPortParamGeneric(classname, paramname, xmlcontainer##loadfunction##0, createFunctor(&classname::loadfunction), 0, xmlelement, loading)
+#define XMLPortParamLoadOnly_Template(classname, paramname, loadtemplate, loadfunction, xmlelement, loading) \
+    XMLPortParamGeneric(classname, paramname, xmlcontainer##loadfunction##0, createFunctor loadtemplate (&classname::loadfunction), 0, xmlelement, loading)
+
+
+#define XMLPortParamGeneric(classname, paramname, containername, loadfunctor, savefunctor, xmlelement, loading) \
+    orxonox::XMLPortClassParamContainer<classname>* containername = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
+    if (!containername) \
     { \
-        xmlcontainer##loadfunction##savefunction = new orxonox::XMLPortClassParamContainer<classname>(this->getIdentifier()->getName(), std::string(paramname), createFunctor(&classname::loadfunction), createFunctor(&classname::savefunction)); \
-        this->getIdentifier()->addXMLPortParamContainer(paramname, xmlcontainer##loadfunction##savefunction); \
+        containername = new orxonox::XMLPortClassParamContainer<classname>(this->getIdentifier()->getName(), std::string(paramname), loadfunctor, savefunctor); \
+        this->getIdentifier()->addXMLPortParamContainer(paramname, containername); \
     } \
-    xmlcontainer##loadfunction##savefunction->port(this, xmlelement, loading)
-
-#define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, loading) \
-    orxonox::XMLPortClassParamContainer<classname>* xmlcontainer##loadfunction##savefunction = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
-    if (!xmlcontainer##loadfunction##savefunction) \
-    { \
-        xmlcontainer##loadfunction##savefunction = new orxonox::XMLPortClassParamContainer<classname>(this->getIdentifier()->getName(), std::string(paramname), createFunctor(&classname::loadfunction), 0); \
-        this->getIdentifier()->addXMLPortParamContainer(paramname, xmlcontainer##loadfunction##savefunction); \
-    } \
-    xmlcontainer##loadfunction##savefunction->port(this, xmlelement, loading)
+    containername->port(this, xmlelement, loading)
+
 
 #define XMLPortObject(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, loading, bApplyLoaderMask, bLoadBefore) \