Changeset 818 for code/branches/core

Timestamp:

Feb 16, 2008, 8:00:06 PM (17 years ago)

Author:

landauf

Message:

new feature in ClassTreeMask:
you can include or exclude a single class without changing the rule for inheriting classes

Location:

code/branches/core/src/orxonox

Files:

• Orxonox.cc (modified) (1 diff)
• core/ClassTreeMask.cc (modified) (8 diffs)
• core/ClassTreeMask.h (modified) (1 diff)

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

@@ -1088 +1088 @@
         std::cout << "12\n";
 
+        ClassTreeMask test13_21;
+        test13_21.excludeSingle(Class(A2));
+        std::cout << std::endl;
+        std::cout << "Mask with single-excluded A2:\n";
+        TestClassTreeMask(test13_21);
+
+        test13_21.exclude(Class(A2));
+        std::cout << std::endl;
+        std::cout << "Mask with excluded A2:\n";
+        TestClassTreeMask(test13_21);
+
+        test13_21.includeSingle(Class(A2));
+        std::cout << std::endl;
+        std::cout << "Previous mask with single-included A2:\n";
+        TestClassTreeMask(test13_21);
+
+        test13_21.includeSingle(Class(A2), false);
+        std::cout << std::endl;
+        std::cout << "Previous mask with single-included A2 without clean:\n";
+        TestClassTreeMask(test13_21);
+
+        std::cout << "13\n";
 /*
         std::cout << "Test 14\n";

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

@@ -62 +62 @@
     /**
         @brief Sets the rule for the node to "included".
+        @param overwrite True = overwrite previously added rules for inheriting classes
     */
     void ClassTreeMaskNode::include(bool overwrite)
@@ -70 +71 @@
     /**
         @brief Sets the rule for the node to "excluded".
+        @param overwrite True = overwrite previously added rules for inheriting classes
     */
     void ClassTreeMaskNode::exclude(bool overwrite)
@@ -79 +81 @@
         @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)
+        @param overwrite True = overwrite previously added rules for inheriting classes
     */
     void ClassTreeMaskNode::setIncluded(bool bIncluded, bool overwrite)
@@ -287 +290 @@
         @brief Adds a new "include" rule for a given subclass to the mask.
         @param subclass The subclass
+        @param overwrite True = overwrite previously added rules for inheriting classes
+        @param clean True = clean the tree after adding the new rule
     */
     void ClassTreeMask::include(const Identifier* subclass, bool overwrite, bool clean)
@@ -296 +301 @@
         @brief Adds a new "exclude" rule for a given subclass to the mask.
         @param subclass The subclass
+        @param overwrite True = overwrite previously added rules for inheriting classes
+        @param clean True = clean the tree after adding the new rule
     */
     void ClassTreeMask::exclude(const Identifier* subclass, bool overwrite, bool clean)
@@ -306 +313 @@
         @param subclass The subclass
         @param bInclude The rule: include (true) or exclude (false)
+        @param overwrite True = overwrite previously added rules for inheriting classes
+        @param clean True = clean the tree after adding the new rule
     */
     void ClassTreeMask::add(const Identifier* subclass, bool bInclude, bool overwrite, bool clean)
@@ -334 +343 @@
         @param subclass The subclass
         @param bInclude The rule: include (true) or exclude (false)
+        @param overwrite True = overwrite previously added rules for inheriting classes
     */
     void ClassTreeMask::add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude, bool overwrite)
@@ -385 +395 @@
 
     /**
+        @brief Adds a new "include" rule for a single subclass. The new rule doesn't change the mask for inheriting classes.
+        @param subclass The subclass
+        @param clean True = clean the tree after adding the new rule
+    */
+    void ClassTreeMask::includeSingle(const Identifier* subclass, bool clean)
+    {
+        this->addSingle(subclass, true, clean);
+    }
+
+    /**
+        @brief Adds a new "exclude" rule for a single subclass. The new rule doesn't change the mask for inheriting classes.
+        @param subclass The subclass
+        @param clean True = clean the tree after adding the new rule
+    */
+    void ClassTreeMask::excludeSingle(const Identifier* subclass, bool clean)
+    {
+        this->addSingle(subclass, false, clean);
+    }
+
+    /**
+        @brief Adds a new rule for a single subclass. The new rule doesn't change the mask for inheriting classes.
+        @param bInclude The rule: include (true) or exclude (false)
+        @param subclass The subclass
+        @param clean True = clean the tree after adding the new rule
+    */
+    void ClassTreeMask::addSingle(const Identifier* subclass, bool bInclude, bool clean)
+    {
+        for (std::list<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
+            this->add(*it, this->isIncluded(*it), false, false);
+
+        this->add(subclass, bInclude, false, clean);
+    }
+
+    /**
         @brief Resets the mask to "include everything".
     */

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

@@ -166 +166 @@
             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 includeSingle(const Identifier* subclass, bool clean = true);
+            void excludeSingle(const Identifier* subclass, bool clean = true);
+            void addSingle(const Identifier* subclass, bool bInclude, bool clean = true);
+
             void reset();
             void clean();