Changeset 9550 for code/trunk/src/libraries/core

Timestamp:

Mar 12, 2013, 11:13:03 PM (11 years ago)

Author:

landauf

Message:

merged testing branch back to trunk. unbelievable it took me 13 months to finish this chore…

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/CommandLineParser.cc (modified) (3 diffs)
• src/libraries/core/CommandLineParser.h (modified) (2 diffs)
• src/libraries/core/ConfigValueContainer.cc (modified) (7 diffs)
• src/libraries/core/Core.cc (modified) (5 diffs)
• src/libraries/core/PathConfig.cc (modified) (2 diffs)
• src/libraries/core/command/CommandEvaluation.cc (modified) (5 diffs)
• src/libraries/core/command/CommandExecutor.cc (modified) (2 diffs)
• src/libraries/core/command/ConsoleCommand.h (modified) (1 diff)
• src/libraries/core/command/Executor.cc (modified) (3 diffs)
• src/libraries/core/command/Executor.h (modified) (1 diff)
• src/libraries/core/command/Functor.h (modified) (7 diffs)
• src/libraries/core/command/IOConsolePOSIX.cc (modified) (3 diffs)
• src/libraries/core/command/IOConsoleWindows.cc (modified) (3 diffs)
• src/libraries/core/command/Shell.cc (modified) (2 diffs)
• src/libraries/core/command/TclBind.cc (modified) (1 diff)
• src/libraries/core/input/InputManager.cc (modified) (1 diff)

code/trunk/src/libraries/core/CommandLineParser.cc

@@ -50 +50 @@
     void CommandLineArgument::parse(const std::string& value)
     {
-        if (value_.getType() == MT_Type::Bool)
+        if (value_.isType<bool>())
         {
             // simulate command line switch
@@ -69 +69 @@
         else
         {
-            if (!value_.setValue(value))
-            {
-                value_.setValue(defaultValue_);
+            if (!value_.set(value))
+            {
+                value_.set(defaultValue_);
                 ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
             }
@@ -298 +298 @@
                 infoStr << "      ";
             infoStr << "--" << it->second->getName() << ' ';
-            if (it->second->getValue().getType() != MT_Type::Bool)
+            if (it->second->getValue().isType<bool>())
+                infoStr << "    ";
+            else
                 infoStr << "ARG ";
-            else
-                infoStr << "    ";
             // fill with the necessary amount of blanks
             infoStr << std::string(maxNameSize - it->second->getName().size(), ' ');

code/trunk/src/libraries/core/CommandLineParser.h

@@ -200 +200 @@
     inline void CommandLineParser::getValue<std::string>(const std::string& name, std::string* value)
     {
-        *value = getArgument(name)->getValue().getString();
+        *value = getArgument(name)->getValue().get<std::string>();
     }
 
@@ -217 +217 @@
         OrxAssert(!_getInstance().existsArgument(name),
             "Cannot add a command line argument with name '" + name + "' twice.");
-        OrxAssert(MultiType(defaultValue).getType() != MT_Type::Bool || MultiType(defaultValue).getBool() != true,
+        OrxAssert(!MultiType(defaultValue).isType<bool>() || MultiType(defaultValue).get<bool>() != true,
                "Boolean command line arguments with positive default values are not supported." << endl
             << "Please use SetCommandLineSwitch and adjust your argument: " << name);

code/trunk/src/libraries/core/ConfigValueContainer.cc

@@ -70 +70 @@
         this->bIsVector_ = false;
 
-        this->defvalueString_ = this->value_.getString();
+        this->defvalueString_ = this->value_.get<std::string>();
         this->update();
     }
@@ -83 +83 @@
         for (unsigned int i = 0; i < this->valueVector_.size(); i++)
         {
-            ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_Type::String));
+            ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType<std::string>());
             this->defvalueStringVector_.push_back(this->valueVector_[i]);
         }
@@ -118 +118 @@
             if (this->tset(input))
             {
-                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, input, this->value_.isType(MT_Type::String));
+                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, input, this->value_.isType<std::string>());
                 return true;
             }
@@ -137 +137 @@
             if (this->tset(index, input))
             {
-                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, index, input, this->value_.isType(MT_Type::String));
+                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, index, input, this->value_.isType<std::string>());
                 return true;
             }
@@ -236 +236 @@
                 this->valueVector_.erase(this->valueVector_.begin() + index);
                 for (unsigned int i = index; i < this->valueVector_.size(); i++)
-                    ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_Type::String));
+                    ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType<std::string>());
                 ConfigFileManager::getInstance().getConfigFile(this->type_)->deleteVectorEntries(this->sectionname_, this->varname_, this->valueVector_.size());
 
@@ -272 +272 @@
     {
         if (!this->bIsVector_)
-            this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType(MT_Type::String));
+            this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType<std::string>());
         else
         {
@@ -281 +281 @@
                 if (i < this->defvalueStringVector_.size())
                 {
-                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType(MT_Type::String));
+                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType<std::string>());
                 }
                 else
                 {
-                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, MultiType(), this->value_.isType(MT_Type::String));
+                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, MultiType(), this->value_.isType<std::string>());
                 }
 

code/trunk/src/libraries/core/Core.cc

@@ -55 +55 @@
 #include "util/Exception.h"
 #include "util/output/LogWriter.h"
+#include "util/output/OutputManager.h"
 #include "util/Scope.h"
 #include "util/ScopedSingletonManager.h"
@@ -167 +168 @@
         this->configFileManager_ = new ConfigFileManager();
         this->configFileManager_->setFilename(ConfigFileType::Settings,
-            CommandLineParser::getValue("settingsFile").getString());
+            CommandLineParser::getValue("settingsFile").get<std::string>());
 
         // Required as well for the config values
@@ -180 +181 @@
 
         // Set the correct log path and rewrite the log file with the correct log levels
-        LogWriter::getInstance().setLogPath(PathConfig::getLogPathString());
+        OutputManager::getInstance().getLogWriter()->setLogDirectory(PathConfig::getLogPathString());
 
 #if !defined(ORXONOX_PLATFORM_APPLE) && !defined(ORXONOX_USE_WINMAIN)
         // Create persistent IO console
-        if (CommandLineParser::getValue("noIOConsole").getBool())
+        if (CommandLineParser::getValue("noIOConsole").get<bool>())
         {
             ModifyConfigValue(bStartIOConsole_, tset, false);
@@ -258 +259 @@
     void Core::setConfigValues()
     {
-        SetConfigValueExternal(LogWriter::getInstance().configurableMaxLevel_,
-                               LogWriter::getInstance().getConfigurableSectionName(),
-                               LogWriter::getInstance().getConfigurableMaxLevelName(),
-                               LogWriter::getInstance().configurableMaxLevel_)
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableMaxLevel_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableMaxLevelName(),
+                               OutputManager::getInstance().getLogWriter()->configurableMaxLevel_)
             .description("The maximum level of output shown in the log file")
-            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableLevel);
-        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContextsMaxLevel_,
-                               LogWriter::getInstance().getConfigurableSectionName(),
-                               LogWriter::getInstance().getConfigurableAdditionalContextsMaxLevelName(),
-                               LogWriter::getInstance().configurableAdditionalContextsMaxLevel_)
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableLevel);
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableAdditionalContextsMaxLevel_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableAdditionalContextsMaxLevelName(),
+                               OutputManager::getInstance().getLogWriter()->configurableAdditionalContextsMaxLevel_)
             .description("The maximum level of output shown in the log file for additional contexts")
-            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContextsLevel);
-        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContexts_,
-                               LogWriter::getInstance().getConfigurableSectionName(),
-                               LogWriter::getInstance().getConfigurableAdditionalContextsName(),
-                               LogWriter::getInstance().configurableAdditionalContexts_)
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableAdditionalContextsLevel);
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableAdditionalContexts_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableAdditionalContextsName(),
+                               OutputManager::getInstance().getLogWriter()->configurableAdditionalContexts_)
             .description("Additional output contexts shown in the log file")
-            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContexts);
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableAdditionalContexts);
 
         SetConfigValue(bDevMode_, PathConfig::buildDirectoryRun())
@@ -337 +338 @@
     {
         orxout(internal_info) << "loading graphics in Core" << endl;
-        
+
         // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
         Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);

code/trunk/src/libraries/core/PathConfig.cc

@@ -188 +188 @@
             // Check for data path override by the command line
             if (!CommandLineParser::getArgument("externalDataPath")->hasDefaultValue())
-                externalDataPath_ = CommandLineParser::getValue("externalDataPath").getString();
+                externalDataPath_ = CommandLineParser::getValue("externalDataPath").get<std::string>();
             else
                 externalDataPath_ = specialConfig::externalDataDevDirectory;
@@ -227 +227 @@
         if (!CommandLineParser::getArgument("writingPathSuffix")->hasDefaultValue())
         {
-            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").getString());
+            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").get<std::string>());
             configPath_ = configPath_ / directory;
             logPath_    = logPath_    / directory;

code/trunk/src/libraries/core/command/CommandEvaluation.cc

@@ -119 +119 @@
         @brief Executes the command which was evaluated by this object and returns its return-value.
         @param error A pointer to an integer (or NULL) which will be used to write error codes to (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
-        @return Returns the result of the command (or MT_Type::Null if there is no return value)
+        @return Returns the result of the command (or MultiType::Null if there is no return value)
     */
     MultiType CommandEvaluation::query(int* error)
@@ -138 +138 @@
 
             if (*error != CommandExecutor::Success)
-                return MT_Type::Null;
+                return MultiType::Null;
         }
 
@@ -170 +170 @@
 
         // return a null value in case of an error
-        return MT_Type::Null;
+        return MultiType::Null;
     }
 
@@ -225 +225 @@
             return this->arguments_[index];
 
-        return MT_Type::Null;
+        return MultiType::Null;
     }
 
@@ -600 +600 @@
             // print the default value if available
             if (command->getExecutor()->defaultValueSet(i))
-                output += '=' + command->getExecutor()->getDefaultValue(i).getString() + ']';
+                output += '=' + command->getExecutor()->getDefaultValue(i).get<std::string>() + ']';
             else
                 output += '}';

code/trunk/src/libraries/core/command/CommandExecutor.cc

@@ -83 +83 @@
         @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
         @param useTcl If true, the command is passed to tcl (see TclBind)
-        @return Returns the return-value of the command (if any - MT_Type::Null otherwise)
+        @return Returns the return-value of the command (if any - MultiType::Null otherwise)
     */
     /* static */ MultiType CommandExecutor::queryMT(const std::string& command, int* error, bool useTcl)
@@ -133 +133 @@
     /* static */ std::string CommandExecutor::query(const std::string& command, int* error, bool useTcl)
     {
-        return CommandExecutor::queryMT(command, error, useTcl).getString();
+        return CommandExecutor::queryMT(command, error, useTcl).get<std::string>();
     }
 

code/trunk/src/libraries/core/command/ConsoleCommand.h

@@ -222 +222 @@
 #include <stack>
 #include <vector>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/facilities/expand.hpp>
 
 #include "util/VA_NARGS.h"

code/trunk/src/libraries/core/command/Executor.cc

@@ -79 +79 @@
         @param delimiter The delimiter that is used to separate the arguments in the string @a arguments
         @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
-        @return Returns the return value of the function (or MT_Type::Null if there is no return value)
+        @return Returns the return value of the function (or MultiType::Null if there is no return value)
     */
     MultiType Executor::parse(const std::string& arguments, int* error, const std::string& delimiter, bool bPrintError) const
@@ -92 +92 @@
         @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
         @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
-        @return Returns the return value of the function (or MT_Type::Null if there is no return value)
+        @return Returns the return value of the function (or MultiType::Null if there is no return value)
     */
     MultiType Executor::parse(const SubString& arguments, int* error, const std::string& delimiter, bool bPrintError) const
@@ -105 +105 @@
             if (bPrintError)
                 orxout(internal_warning) << "Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << endl;
-            return MT_Type::Null;
+            return MultiType::Null;
         }
 

code/trunk/src/libraries/core/command/Executor.h

@@ -169 +169 @@
                     return this->defaultValue_[index];
 
-                return MT_Type::Null;
+                return MultiType::Null;
             }
 

code/trunk/src/libraries/core/command/Functor.h

@@ -189 +189 @@
             virtual ~Functor() {}
 
-            /// Calls the function-pointer with up to five arguments. In case of a member-function, the assigned object-pointer is used to call the function. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
-            virtual MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            /// Calls the function-pointer with up to five arguments. In case of a member-function, the assigned object-pointer is used to call the function. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            virtual MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             /// Creates a new instance of Functor with the same values like this (used instead of a copy-constructor)
@@ -245 +245 @@
             virtual ~FunctorMember() { if (this->bSafeMode_) { this->unregisterObject(this->object_); } }
 
-            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
-            virtual MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            virtual MultiType operator()(O* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             // see Functor::operator()()
-            MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
+            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
             {
                 // call the function if an object was assigned
@@ -257 +257 @@
                 {
                     orxout(internal_error) << "Can't execute FunctorMember, no object set." << endl;
-                    return MT_Type::Null;
+                    return MultiType::Null;
                 }
             }
@@ -324 +324 @@
             FunctorMember(void* object = 0) {}
 
-            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
-            virtual MultiType operator()(void* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            virtual MultiType operator()(void* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             // see Functor::operator()()
-            MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
+            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
             {
                 return (*this)((void*)0, param1, param2, param3, param4, param5);
@@ -416 +416 @@
         template <class R, class O, bool isconst, class P1>                                         struct FunctorCaller<R, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1); } };
         template <class R, class O, bool isconst>                                                   struct FunctorCaller<R, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(); } };
-        template <class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (object->*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1, class P2>                               struct FunctorCaller<void, O, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1>                                         struct FunctorCaller<void, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1); return MT_Type::Null; } };
-        template <class O, bool isconst>                                                   struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(); return MT_Type::Null; } };
+        template <class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4, param5); return MultiType::Null; } };
+        template <class O, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (object->*functionPointer)(param1, param2, param3, param4); return MultiType::Null; } };
+        template <class O, bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2, param3); return MultiType::Null; } };
+        template <class O, bool isconst, class P1, class P2>                               struct FunctorCaller<void, O, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2); return MultiType::Null; } };
+        template <class O, bool isconst, class P1>                                         struct FunctorCaller<void, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1); return MultiType::Null; } };
+        template <class O, bool isconst>                                                   struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(); return MultiType::Null; } };
         template <class R, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1, param2, param3, param4, param5); } };
         template <class R, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { return (*functionPointer)(param1, param2, param3, param4); } };
@@ -428 +428 @@
         template <class R, bool isconst, class P1>                                         struct FunctorCaller<R, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(param1); } };
         template <class R, bool isconst>                                                   struct FunctorCaller<R, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(); } };
-        template <bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
-        template <bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
-        template <bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
-        template <bool isconst, class P1, class P2>                               struct FunctorCaller<void, void, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2); return MT_Type::Null; } };
-        template <bool isconst, class P1>                                         struct FunctorCaller<void, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1); return MT_Type::Null; } };
-        template <bool isconst>                                                   struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(); return MT_Type::Null; } };
+        template <bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3, param4, param5); return MultiType::Null; } };
+        template <bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (*functionPointer)(param1, param2, param3, param4); return MultiType::Null; } };
+        template <bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2, param3); return MultiType::Null; } };
+        template <bool isconst, class P1, class P2>                               struct FunctorCaller<void, void, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2); return MultiType::Null; } };
+        template <bool isconst, class P1>                                         struct FunctorCaller<void, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1); return MultiType::Null; } };
+        template <bool isconst>                                                   struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(); return MultiType::Null; } };
 
         // Helper class, used to identify the header of a function-pointer (independent of its class)
@@ -497 +497 @@
 
             // see FunctorMember::operator()()
-            MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
+            MultiType operator()(O* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
             {
                 return detail::FunctorCaller<R, O, isconst, P1, P2, P3, P4, P5>::call(this->functionPointer_, object, param1, param2, param3, param4, param5);

code/trunk/src/libraries/core/command/IOConsolePOSIX.cc

@@ -38 +38 @@
 #include "util/Math.h"
 #include "util/output/ConsoleWriter.h"
+#include "util/output/OutputManager.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
@@ -75 +76 @@
 
         // Disable standard std::cout logging
-        ConsoleWriter::getInstance().disable();
+        OutputManager::getInstance().getConsoleWriter()->disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
@@ -103 +104 @@
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard std::cout logging again
-        ConsoleWriter::getInstance().enable();
+        OutputManager::getInstance().getConsoleWriter()->enable();
     }
 

code/trunk/src/libraries/core/command/IOConsoleWindows.cc

@@ -35 +35 @@
 #include "util/Math.h"
 #include "util/output/ConsoleWriter.h"
+#include "util/output/OutputManager.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
@@ -53 +54 @@
     {
         // Disable standard this->cout_ logging
-        ConsoleWriter::getInstance().disable();
+        OutputManager::getInstance().getConsoleWriter()->disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
@@ -109 +110 @@
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard this->cout_ logging again
-        ConsoleWriter::getInstance().enable();
+        OutputManager::getInstance().getConsoleWriter()->enable();
 
         resetTerminalMode();

code/trunk/src/libraries/core/command/Shell.cc

@@ -88 +88 @@
 
         // Get the previous output and add it to the Shell
-        MemoryWriter::getInstance().resendOutput(this);
+        OutputManager::getInstance().getMemoryWriter()->resendOutput(this);
     }
 
@@ -170 +170 @@
         {
             OutputLevel level = (value ? DefaultLogLevel::Dev : DefaultLogLevel::User);
-            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), tset, level);
+            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), tset, static_cast<int>(level));
         }
     }

code/trunk/src/libraries/core/command/TclBind.cc

@@ -183 +183 @@
 
         if (bQuery)
-            result = evaluation.query(&error).getString();
+            result = evaluation.query(&error).get<std::string>();
         else
             error = evaluation.execute();

code/trunk/src/libraries/core/input/InputManager.cc

@@ -176 +176 @@
         if (exclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
         {
-            if (CommandLineParser::getValue("keyboard_no_grab").getBool())
+            if (CommandLineParser::getValue("keyboard_no_grab").get<bool>())
                 paramList.insert(StringPair("x11_keyboard_grab", "false"));
             else