Changeset 8833 for code/branches/output/src/libraries/util/output/OutputManager.cc

Timestamp:

Aug 11, 2011, 11:20:39 PM (13 years ago)

Author:

landauf

Message:

A context is now defined by a struct instead of only a mask.

Introduced sub-contexts. Sub-contexts of the same main-context share the same mask, but have a different ID.
Main-contexts are filtered using a bitmask which happens for every line of output and is very fast.
Sub-contexts are filtered using a set which is slow but happens only if a specific sub-context is enabled in the config file which is usually not the case.

The concept of filtering normal output + additional contexts was moved from BaseWriter directly to OutputListener and OutputManager which makes the whole system faster.
BaseWriter now calls registerContext() for each configured output context, which basically allows the usage of more than 64 contexts as long as these contexts are not used before loading the config file. Though by design it's not recommended.

File:

• code/branches/output/src/libraries/util/output/OutputManager.cc (modified) (6 diffs)

code/branches/output/src/libraries/util/output/OutputManager.cc

@@ -32 +32 @@
 #include "ConsoleWriter.h"
 #include "LogWriter.h"
+#include "util/Output.h"
 #include "util/StringUtils.h"
 
@@ -39 +40 @@
     {
         this->combinedLevelMask_ = level::none;
-        this->combinedContextMask_ = 0;
+        this->combinedAdditionalContextsLevelMask_ = level::none;
+        this->combinedAdditionalContextsMask_ = context::none;
+
+        this->subcontextCounter_ = 0;
     }
 
@@ -63 +67 @@
     }
 
-    void OutputManager::pushMessage(OutputLevel level, OutputContext context, const std::string& message)
+    void OutputManager::pushMessage(OutputLevel level, const OutputContextContainer& context, const std::string& message)
     {
         std::vector<std::string> lines;
@@ -94 +98 @@
     {
         this->updateCombinedLevelMask();
-        this->updateCombinedContextMask();
+        this->updateCombinedAdditionalContextsLevelMask();
+        this->updateCombinedAdditionalContextsMask();
     }
 
@@ -105 +110 @@
     }
 
-    void OutputManager::updateCombinedContextMask()
+    void OutputManager::updateCombinedAdditionalContextsLevelMask()
     {
-        this->combinedContextMask_ = 0;
+        int mask = 0;
         for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->combinedContextMask_ |= this->listeners_[i]->getContextMask();
+            mask |= this->listeners_[i]->getAdditionalContextsLevelMask();
+        this->combinedAdditionalContextsLevelMask_ = static_cast<OutputLevel>(mask);
     }
 
-    OutputContext OutputManager::registerContext(const std::string& name)
+    void OutputManager::updateCombinedAdditionalContextsMask()
     {
-        boost::bimap<OutputContext, std::string>::right_map::iterator it = this->contexts_.right.find(name);
-        if (it == this->contexts_.right.end())
+        this->combinedAdditionalContextsMask_ = 0;
+        for (size_t i = 0; i < this->listeners_.size(); ++i)
+            this->combinedAdditionalContextsMask_ |= this->listeners_[i]->getAdditionalContextsMask();
+    }
+
+    const OutputContextContainer& OutputManager::registerContext(const std::string& name, const std::string& subname)
+    {
+        std::string full_name = name;
+        if (subname != "")
+            full_name += "::" + subname;
+
+        std::map<std::string, OutputContextContainer>::iterator it_container = this->contextContainers_.find(full_name);
+        if (it_container != this->contextContainers_.end())
+            return it_container->second;
+
+        OutputContextContainer container;
+        container.name = full_name;
+
+        std::map<std::string, OutputContextMask>::iterator it_mask = this->contextMasks_.find(name);
+        if (it_mask != this->contextMasks_.end())
         {
-            OutputContext context = 0x1 << this->contexts_.size();
-            this->contexts_.insert(boost::bimap<OutputContext, std::string>::value_type(context, name));
-            return context;
+            container.mask = it_mask->second;
         }
         else
         {
-            return it->second;
+            container.mask = static_cast<OutputContextMask>(0x1) << this->contextMasks_.size();
+            this->contextMasks_[name] = container.mask;
+
+            if (container.mask == 0)
+                orxout(internal_warning) << "More than " << sizeof(OutputContextMask) * 8 << " output contexts defined. Context '" << name << "' might not get filtered correctly" << endl;
         }
+
+        if (subname == "")
+            container.sub_id = context::no_subcontext;
+        else
+            container.sub_id = ++this->subcontextCounter_; // start with 1
+
+        return (this->contextContainers_[full_name] = container);
     }
 
-    OutputContext registerContext(const std::string& name)
+    const OutputContextContainer& registerContext(const std::string& name, const std::string& subname)
     {
-        return OutputManager::getInstance().registerContext(name);
+        return OutputManager::getInstance().registerContext(name, subname);
     }
 
@@ -154 +187 @@
     }
 
-    const std::string& OutputManager::getContextName(OutputContext context) const
+    std::string OutputManager::getDefaultPrefix(OutputLevel level, const OutputContextContainer& context) const
     {
-        if (context != context::undefined())
-        {
-            boost::bimap<OutputContext, std::string>::left_map::const_iterator it = this->contexts_.left.find(context);
-            if (it != this->contexts_.left.end())
-                return it->second;
-        }
-        return BLANKSTRING;
-    }
+        static OutputContextMask undefined_mask = context::undefined().mask;
 
-    OutputContext OutputManager::getContextValue(const std::string& name) const
-    {
-        boost::bimap<OutputContext, std::string>::right_map::const_iterator it = this->contexts_.right.find(name);
-        if (it != this->contexts_.right.end())
-            return it->second;
-        else
-            return context::none;
-    }
+        std::string prefix = this->getLevelName(level) + ": ";
+        if (context.mask != undefined_mask)
+            prefix += "[" + context.name + "] ";
 
-    std::string OutputManager::getComposedContextName(OutputContext context) const
-    {
-        std::string name;
-        size_t counter = 0;
-        for (OutputContext context_test = 0x1; context_test != 0x0; context_test = context_test << 1)
-        {
-            if (context & context_test)
-            {
-                boost::bimap<OutputContext, std::string>::left_map::const_iterator it = this->contexts_.left.find(context_test);
-                if (it != this->contexts_.left.end())
-                {
-                    if (counter)
-                        name += ", ";
-
-                    name += it->second;
-                    ++counter;
-                }
-            }
-        }
-        return name;
-    }
-
-    std::string OutputManager::getDefaultPrefix(OutputLevel level, OutputContext context) const
-    {
-        std::string prefix = this->getLevelName(level) + ": ";
-        if (context != context::undefined())
-        {
-            std::string context_name = this->getContextName(context);
-            if (context_name == "")
-                context_name = this->getComposedContextName(context);
-            prefix += "[" + context_name + "] ";
-        }
         return prefix;
     }