Changeset 8799 for code/branches

Timestamp:

Jul 30, 2011, 7:51:08 PM (13 years ago)

Author:

landauf

Message:

Code related to config values for output is now implemented in BaseWriter.
There's a config value for the normal output level, a vector with additional contexts, and a config value for the level of these additional contexts.
ioconsole and standard console use the same values.

Location:

code/branches/output/src/libraries

Files:

• core/Core.cc (modified) (3 diffs)
• core/Core.h (modified) (1 diff)
• core/GUIManager.cc (modified) (2 diffs)
• core/command/IOConsolePOSIX.cc (modified) (1 diff)
• core/command/IOConsoleWindows.cc (modified) (1 diff)
• core/command/Shell.cc (modified) (6 diffs)
• core/command/Shell.h (modified) (1 diff)
• util/output/BaseWriter.cc (modified) (2 diffs)
• util/output/BaseWriter.h (modified) (3 diffs)
• util/output/ConsoleWriter.cc (modified) (1 diff)
• util/output/LogWriter.cc (modified) (1 diff)
• util/output/OutputDefinitions.h (modified) (1 diff)
• util/output/OutputManager.cc (modified) (1 diff)
• util/output/OutputManager.h (modified) (1 diff)

code/branches/output/src/libraries/core/Core.cc

@@ -50 +50 @@
 #  undef max
 #endif
-
-#include <boost/preprocessor/stringize.hpp>
 
 #include "util/Clock.h"
@@ -231 +229 @@
     }
 
-    namespace DefaultLevelLogFile
-    {
-#pragma message(__FILE__ "("BOOST_PP_STRINGIZE(__LINE__)") : Warning: TODO: inspect this (and remove boost include)")
-        const OutputLevel Dev  = level::internal_info;
-        const OutputLevel User = level::internal_info;
-    }
-
     //! Function to collect the SetConfigValue-macro calls.
     void Core::setConfigValues()
     {
-        // Choose the default level according to the path Orxonox was started (build directory or not)
-        OutputLevel defaultLogLevel = (PathConfig::buildDirectoryRun() ? DefaultLevelLogFile::Dev : DefaultLevelLogFile::User);
-
-        SetConfigValueExternal(debugLevelLogFile_, "OutputHandler", "debugLevelLogFile", defaultLogLevel)
-            .description("The maximum level of debug output written to the log file");
-        LogWriter::getInstance().setLevelMax(this->debugLevelLogFile_);
+        SetConfigValueExternal(LogWriter::getInstance().configurableMaxLevel_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableMaxLevelName(),
+                               LogWriter::getInstance().configurableMaxLevel_)
+            .description("The maximum level of output shown in the log file")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableLevels);
+        SetConfigValueExternal(LogWriter::getInstance().configurableContextsMaxLevel_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableContextsMaxLevelName(),
+                               LogWriter::getInstance().configurableContextsMaxLevel_)
+            .description("The maximum level of output shown in the log file for additional contexts")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableLevels);
+        SetConfigValueExternal(LogWriter::getInstance().configurableContexts_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableContextsName(),
+                               LogWriter::getInstance().configurableContexts_)
+            .description("Additional output contexts shown in the log file")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableContexts);
 
         SetConfigValue(bDevMode_, PathConfig::buildDirectoryRun())
@@ -281 +284 @@
     void Core::devModeChanged()
     {
-        bool isNormal = (bDevMode_ == PathConfig::buildDirectoryRun());
-        if (isNormal)
-        {
-            ModifyConfigValueExternal(debugLevelLogFile_, "debugLevelLogFile", update);
-        }
-        else
-        {
-            OutputLevel level = (bDevMode_ ? DefaultLevelLogFile::Dev : DefaultLevelLogFile::User);
-            ModifyConfigValueExternal(debugLevelLogFile_, "debugLevelLogFile", tset, level);
-        }
-
         // Inform listeners
         ObjectList<DevModeListener>::iterator it = ObjectList<DevModeListener>::begin();

code/branches/output/src/libraries/core/Core.h

@@ -136 +136 @@
 
             bool                      bGraphicsLoaded_;
-            OutputLevel               debugLevelLogFile_;          //!< The debug level for the log file (belongs to LogWriter)
             std::string               language_;                   //!< The language
             bool                      bInitRandomNumberGenerator_; //!< If true, srand(time(0)) is called

code/branches/output/src/libraries/core/GUIManager.cc

@@ -77 +77 @@
 #include "util/Math.h"
 #include "util/OrxAssert.h"
+#include "util/output/BaseWriter.h"
 #include "ConfigValueIncludes.h"
 #include "Core.h"
@@ -368 +369 @@
         SetConfigValue(guiScheme_, GUIManager::defaultScheme_).description("Changes the current GUI scheme.").callback(this, &GUIManager::changedGUIScheme);
         SetConfigValue(numScrollLines_, 1).description("How many lines to scroll in a list if the scroll wheel is used");
-        SetConfigValueExternal(outputLevelCeguiLog_, "OutputHandler", "outputLevelCeguiLog", CEGUI::Standard).description("The log level of the CEGUI log file").callback(this, &GUIManager::changedCeguiOutputLevel);
+        SetConfigValueExternal(outputLevelCeguiLog_, BaseWriter::getConfigurableSectionName(), "outputLevelCeguiLog", CEGUI::Standard).description("The log level of the CEGUI log file").callback(this, &GUIManager::changedCeguiOutputLevel);
     }
 

code/branches/output/src/libraries/core/command/IOConsolePOSIX.cc

@@ -56 +56 @@
 
     IOConsole::IOConsole()
-        : shell_(new Shell("IOConsole", false))
+        : shell_(new Shell("Console", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())

code/branches/output/src/libraries/core/command/IOConsoleWindows.cc

@@ -44 +44 @@
     //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
     IOConsole::IOConsole()
-        : shell_(new Shell("IOConsole", false))
+        : shell_(new Shell("Console", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())

code/branches/output/src/libraries/core/command/Shell.cc

@@ -56 +56 @@
     unsigned int Shell::cacheSize_s;
 
+    namespace DefaultLogLevel
+    {
+        const OutputLevel Dev  = level::internal_warning;
+        const OutputLevel User = level::user_info;
+    }
+
     /**
         @brief Constructor: Initializes the values.
@@ -62 +68 @@
     */
     Shell::Shell(const std::string& consoleName, bool bScrollable)
-        : inputBuffer_(new InputBuffer())
-        , consoleName_(consoleName)
+        : BaseWriter(consoleName)
+        , inputBuffer_(new InputBuffer())
         , bScrollable_(bScrollable)
     {
@@ -79 +85 @@
         ConfigFileManager::getInstance().setFilename(ConfigFileType::CommandHistory, "commandHistory.ini");
 
+        // Choose the default level according to the path Orxonox was started (build directory or not)
+        OutputLevel defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        this->setLevelMax(defaultDebugLevel);
+
         this->setConfigValues();
 
@@ -91 +101 @@
     {
         this->inputBuffer_->destroy();
-    }
-
-    namespace DefaultLogLevel
-    {
-        const OutputLevel Dev  = level::internal_warning;
-        const OutputLevel User = level::user_info;
     }
 
@@ -111 +115 @@
         SetConfigValue(cacheSize_s, 32);
 
-        // Choose the default level according to the path Orxonox was started (build directory or not)
-        OutputLevel defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
-        SetConfigValueExternal(debugLevel_, "OutputHandler", "debugLevel" + consoleName_, defaultDebugLevel)
-            .description("The maximum level of debug output shown in the " + consoleName_);
-        this->setLevelMax(this->debugLevel_);
+        SetConfigValueExternal(this->configurableMaxLevel_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableMaxLevelName(),
+                               this->configurableMaxLevel_)
+            .description("The maximum level of output shown in the " + this->getName())
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableLevels);
+        SetConfigValueExternal(this->configurableContextsMaxLevel_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableContextsMaxLevelName(),
+                               this->configurableContextsMaxLevel_)
+            .description("The maximum level of output shown in the " + this->getName() + " for additional contexts")
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableLevels);
+        SetConfigValueExternal(this->configurableContexts_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableContextsName(),
+                               this->configurableContexts_)
+            .description("Additional output contexts shown in the " + this->getName())
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableLevels);
     }
 
@@ -150 +167 @@
         if (isNormal)
         {
-            ModifyConfigValueExternal(debugLevel_, "debugLevel" + consoleName_, update);
+            ModifyConfigValueExternal(debugLevel_, this->getConfigurableMaxLevelName(), update);
         }
         else
         {
             OutputLevel level = (value ? DefaultLogLevel::Dev : DefaultLogLevel::User);
-            ModifyConfigValueExternal(debugLevel_, "debugLevel" + consoleName_, tset, level);
+            ModifyConfigValueExternal(debugLevel_, this->getConfigurableMaxLevelName(), tset, level);
         }
     }

code/branches/output/src/libraries/core/command/Shell.h

@@ -191 +191 @@
             unsigned int              scrollPosition_;      ///< The number of the line that is currently being referenced by scrollIterator_
             unsigned int              historyPosition_;     ///< If the user scrolls through the history of entered commands (stored in commandHistory_), this contains the currently viewed history entry
-
-            const std::string         consoleName_;         ///< The name of this shell - used to define the name of the soft-debug-level config-value
             const bool                bScrollable_;         ///< If true, the user can scroll through the output-lines
 

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

@@ -33 +33 @@
 namespace orxonox
 {
-    BaseWriter::BaseWriter()
+    BaseWriter::BaseWriter(const std::string& name)
     {
+        this->name_ = name;
+
+        this->configurableMaxLevel_ = level::none;
+        this->configurableContextsMaxLevel_ = level::verbose;
     }
 
@@ -43 +47 @@
     void BaseWriter::output(OutputLevel level, OutputContext context, const std::vector<std::string>& lines)
     {
-        const std::string& prefix = OutputManager::getInstance().getDefaultPrefix(level, context);
-        std::string blanks(prefix.length(), ' ');
+        if (level <= this->configurableMaxLevel_ || (level <= this->configurableContextsMaxLevel_ && this->isAdditionalContext(context)))
+        {
+            const std::string& prefix = OutputManager::getInstance().getDefaultPrefix(level, context);
+            std::string blanks(prefix.length(), ' ');
 
-        for (size_t i = 0; i < lines.size(); ++i)
-            this->printLine((i == 0 ? prefix : blanks) + lines[i], level);
+            for (size_t i = 0; i < lines.size(); ++i)
+                this->printLine((i == 0 ? prefix : blanks) + lines[i], level);
+        }
+    }
+
+    void BaseWriter::setLevelMax(OutputLevel max)
+    {
+        this->configurableMaxLevel_ = max;
+        this->changedConfigurableLevels();
+    }
+
+    void BaseWriter::changedConfigurableLevels()
+    {
+        OutputLevel max_level = std::max(this->configurableMaxLevel_, this->configurableContextsMaxLevel_);
+        OutputListener::setLevelMax(max_level);
+    }
+
+    void BaseWriter::changedConfigurableContexts()
+    {
+        this->configurableContextsSet_.clear();
+        for (size_t i = 0; i < this->configurableContexts_.size(); ++i)
+            this->configurableContextsSet_.insert(this->configurableContexts_[i]);
+    }
+
+    bool BaseWriter::isAdditionalContext(OutputContext context) const
+    {
+        const std::string& name = OutputManager::getInstance().getContextName(context);
+        std::set<std::string>::const_iterator it = this->configurableContextsSet_.find(name);
+        return (it != this->configurableContextsSet_.end());
     }
 }

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

@@ -31 +31 @@
 
 #include "util/UtilPrereqs.h"
+
+#include <set>
+#include <vector>
+
 #include "OutputListener.h"
 
@@ -38 +42 @@
     {
         public:
-            BaseWriter();
+            BaseWriter(const std::string& name);
             virtual ~BaseWriter();
+
+            const std::string& getName() const
+                { return this->name_; }
+
+            void setLevelMax(OutputLevel max);
+
+            OutputLevel configurableMaxLevel_;
+            inline std::string getConfigurableMaxLevelName() const
+                { return "outputLevel" + this->name_; }
+
+            OutputLevel configurableContextsMaxLevel_;
+            inline std::string getConfigurableContextsMaxLevelName() const
+                { return "outputContextsLevel" + this->name_; }
+
+            std::vector<std::string> configurableContexts_;
+            inline std::string getConfigurableContextsName() const
+                { return "outputContexts" + this->name_; }
+
+            void changedConfigurableLevels();
+            void changedConfigurableContexts();
+
+            static inline std::string getConfigurableSectionName()
+                { return "Output"; }
 
         protected:
@@ -46 +73 @@
         private:
             virtual void printLine(const std::string& line, OutputLevel level) = 0;
+
+            void setLevelRange(OutputLevel min, OutputLevel max);
+            void setLevelMask(OutputLevel mask);
+
+            bool isAdditionalContext(OutputContext context) const;
+
+            std::string name_;
+            std::set<std::string> configurableContextsSet_;
     };
 }

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

@@ -35 +35 @@
 namespace orxonox
 {
-    ConsoleWriter::ConsoleWriter()
+    ConsoleWriter::ConsoleWriter() : BaseWriter("Console")
     {
 #ifdef ORXONOX_RELEASE

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

@@ -36 +36 @@
 namespace orxonox
 {
-    LogWriter::LogWriter()
+    LogWriter::LogWriter() : BaseWriter("Log")
     {
         this->setLevelMax(level::internal_info);
 
-        this->filename_ = "orxonox2.log";
+        this->filename_ = "orxonox.log";
 
         // Get path for a temporary file

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

@@ -44 +44 @@
         static const OutputLevel all              = 0xFFFF;
         static const OutputLevel none             = 0x0000;
+
         static const OutputLevel debug_output     = 0x0001;
         static const OutputLevel user_error       = 0x0002;

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

@@ -166 +166 @@
     }
 
+    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 OutputManager::getComposedContextName(OutputContext context) const
     {

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

@@ -66 +66 @@
             const std::string& getLevelName(OutputLevel level) const;
             const std::string& getContextName(OutputContext context) const;
+            OutputContext getContextValue(const std::string& name) const;
+
             std::string getComposedContextName(OutputContext context) const;
             std::string getDefaultPrefix(OutputLevel level, OutputContext context) const;