Changeset 8771

Timestamp:

Jul 24, 2011, 1:22:11 AM (13 years ago)

Author:

landauf

Message:

added function to register new output contexts.
OutputManager owns helper functions to return names of output levels and contexts.
OutputStream now also seems to compile and link with msvc.

Location:

code/branches/output/src/libraries/util/output

Files:

• OutputDefinitions.h (modified) (2 diffs)
• OutputManager.cc (modified) (2 diffs)
• OutputManager.h (modified) (3 diffs)
• OutputStream.h (modified) (2 diffs)

code/branches/output/src/libraries/util/output/OutputDefinitions.h

@@ -31 +31 @@
 
 #include "util/UtilPrereqs.h"
+#include <string>
 
 namespace orxonox
@@ -58 +59 @@
     typedef uint64_t OutputContext;
 
+    extern _UtilExport OutputContext registerContext(const std::string& name);
+
     namespace context
     {
         static const OutputContext all       = 0xFFFFFFFFFFFFFFFF;
         static const OutputContext none      = 0x0000000000000000;
-        static const OutputContext undefined = 0x0000000000000001;
+        static const OutputContext undefined = registerContext("undefined");
 
-        static const OutputContext test1     = 0x0000000000000002;
-        static const OutputContext test2     = 0x0000000000000004;
+        static const OutputContext test1     = registerContext("test1");
+        static const OutputContext test2     = registerContext("test2");
     }
 }

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

@@ -47 +47 @@
             virtual void output(OutputLevel level, OutputContext context, const std::string& message)
             {
-                COUT(0) << (int)level << " / " << context << " : " << message << endl;
+                COUT(0) << OutputManager::getInstance().getLevelName(level) << " / " << OutputManager::getInstance().getContextName(context) << " : " << message << endl;
             }
     };
@@ -119 +119 @@
             this->combinedContextMask_ |= this->listeners_[i]->getContextMask();
     }
+
+    OutputContext OutputManager::registerContext(const std::string& name)
+    {
+        boost::bimap<OutputContext, std::string>::right_map::iterator it = this->contexts_.right.find(name);
+        if (it == this->contexts_.right.end())
+        {
+            OutputContext context = 0x1 << this->contexts_.size();
+            this->contexts_.insert(boost::bimap<OutputContext, std::string>::value_type(context, name));
+            return context;
+        }
+        else
+        {
+            return it->second;
+        }
+    }
+
+    OutputContext registerContext(const std::string& name)
+    {
+        COUT(0) << "### register context " << name << std::endl;
+        return OutputManager::getInstance().registerContext(name);
+    }
+
+    const std::string& OutputManager::getLevelName(OutputLevel level) const
+    {
+        switch (level)
+        {
+            case level::none:               { static std::string name = "None"; return name; }
+            case level::debug_output:       { static std::string name = "Debug"; return name; }
+            case level::user_error:         { static std::string name = "Error"; return name; }
+            case level::user_warning:       { static std::string name = "Warning"; return name; }
+            case level::user_status:        { static std::string name = "Status"; return name; }
+            case level::user_info:          { static std::string name = "Info"; return name; }
+            case level::internal_error:     { static std::string name = "Error (internal)"; return name; }
+            case level::internal_warning:   { static std::string name = "Warning (internal)"; return name; }
+            case level::internal_status:    { static std::string name = "Status (internal)"; return name; }
+            case level::internal_info:      { static std::string name = "Info (internal)"; return name; }
+            case level::verbose:            { static std::string name = "Verbose"; return name; }
+            case level::verbose_more:       { static std::string name = "Verbose (more)"; return name; }
+            case level::verbose_ultra:      { static std::string name = "Verbose (ultra)"; return name; }
+            default:                        { static std::string name = ""; return name; }
+        }
+    }
+
+    const std::string& OutputManager::getContextName(OutputContext 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;
+            }
+            else
+            {
+                static std::string composed_context;
+                composed_context = "";
+                size_t counter = 0;
+                for (OutputContext context_test = 0x1; context_test != 0x0; context_test = context_test << 1)
+                {
+                    if (context & context_test)
+                    {
+                        it = this->contexts_.left.find(context_test);
+                        if (it != this->contexts_.left.end())
+                        {
+                            if (counter)
+                                composed_context += ", ";
+
+                            composed_context += it->second;
+                            ++counter;
+                        }
+                    }
+                }
+                return composed_context;
+            }
+        }
+        return BLANKSTRING;
+    }
 }
 }

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

@@ -34 +34 @@
 #include <vector>
 
+#include <boost/bimap.hpp>
+
 #include "OutputDefinitions.h"
 
@@ -66 +68 @@
                 { return ((this->combinedLevelMask_ & level) && (this->combinedContextMask_ & context)); }
 
+            OutputContext registerContext(const std::string& name);
+
+            const std::string& getLevelName(OutputLevel level) const;
+            const std::string& getContextName(OutputContext context) const;
+
         private:
             OutputManager();
@@ -77 +84 @@
             OutputLevel   combinedLevelMask_;
             OutputContext combinedContextMask_;
+
+            boost::bimap<OutputContext, std::string> contexts_;
     };
 }

code/branches/output/src/libraries/util/output/OutputStream.h

@@ -40 +40 @@
 namespace test
 {
-    class _UtilExport OutputStream : public std::ostringstream
+    class OutputStream : public std::ostringstream
     {
         typedef std::ostream& (*EndlType)(std::ostream&);
 
         public:
-            OutputStream();
+            _UtilExport OutputStream();
 
-            void setOutputAttributes(OutputLevel level, OutputContext context);
+            void _UtilExport setOutputAttributes(OutputLevel level, OutputContext context);
 
             template <class T>
@@ -74 +74 @@
             }
 
-            void sendMessage();
+            void _UtilExport sendMessage();
 
             OutputLevel level_;