Changeset 10624 for code/trunk/src/libraries/core/command

Timestamp:

Oct 4, 2015, 9:12:21 PM (9 years ago)

Author:

landauf

Message:

merged branch core7 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/command/ArgumentCompletionFunctions.cc (modified) (5 diffs)
• src/libraries/core/command/CMakeLists.txt (modified) (1 diff)
• src/libraries/core/command/CommandEvaluation.cc (modified) (4 diffs)
• src/libraries/core/command/CommandExecutor.cc (modified) (6 diffs)
• src/libraries/core/command/ConsoleCommand.cc (modified) (9 diffs)
• src/libraries/core/command/ConsoleCommand.h (modified) (7 diffs)
• src/libraries/core/command/ConsoleCommandCompilation.cc (modified) (1 diff)
• src/libraries/core/command/ConsoleCommandIncludes.cc (copied) (copied from code/branches/core7/src/libraries/core/command/ConsoleCommandIncludes.cc)
• src/libraries/core/command/ConsoleCommandIncludes.h (copied) (copied from code/branches/core7/src/libraries/core/command/ConsoleCommandIncludes.h)
• src/libraries/core/command/ConsoleCommandManager.cc (copied) (copied from code/branches/core7/src/libraries/core/command/ConsoleCommandManager.cc)
• src/libraries/core/command/ConsoleCommandManager.h (copied) (copied from code/branches/core7/src/libraries/core/command/ConsoleCommandManager.h)
• src/libraries/core/command/IRC.cc (modified) (1 diff)
• src/libraries/core/command/Shell.cc (modified) (3 diffs)
• src/libraries/core/command/Shell.h (modified) (1 diff)
• src/libraries/core/command/TclBind.cc (modified) (2 diffs)
• src/libraries/core/command/TclThreadManager.cc (modified) (1 diff)

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

@@ -44 +44 @@
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
+#include "ConsoleCommandManager.h"
 #include "TclThreadManager.h"
 
@@ -98 +99 @@
 
                 // get all the groups that are visible (except the shortcut group "")
-                const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommand::getCommands();
+                const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommandManager::getInstance().getCommands();
                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
                     if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find(fragmentLC) == 0))
@@ -137 +138 @@
 
                 // find the iterator of the given group
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().begin();
-                for ( ; it_group != ConsoleCommand::getCommands().end(); ++it_group)
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
+                for ( ; it_group != ConsoleCommandManager::getInstance().getCommands().end(); ++it_group)
                     if (getLowercase(it_group->first) == groupLC)
                         break;
 
                 // add all commands in the group to the list
-                if (it_group != ConsoleCommand::getCommands().end())
+                if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                 {
                     for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
@@ -206 +207 @@
                 return detail::_groupsandcommands(fragment, true);
 
-            if (ConsoleCommand::getCommandLC(getLowercase(tokens[0])))
+            if (ConsoleCommandManager::getInstance().getCommandLC(getLowercase(tokens[0])))
                 return ARGUMENT_COMPLETION_FUNCTION_CALL(command)(fragment);
 
             if (tokens.size() == 1)
             {
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().find(tokens[0]);
-                if (it_group != ConsoleCommand::getCommands().end())
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
+                if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                     return detail::_subcommands(fragment, tokens[0], true);
                 else
@@ -218 +219 @@
             }
 
-            if (ConsoleCommand::getCommandLC(getLowercase(tokens[0]), getLowercase(tokens[1])))
+            if (ConsoleCommandManager::getInstance().getCommandLC(getLowercase(tokens[0]), getLowercase(tokens[1])))
                 return ARGUMENT_COMPLETION_FUNCTION_CALL(command)(fragment);
 

code/trunk/src/libraries/core/command/CMakeLists.txt

@@ -4 +4 @@
   ConsoleCommand.cc
   ConsoleCommandCompilation.cc
+  ConsoleCommandIncludes.cc
+  ConsoleCommandManager.cc
   Executor.cc
   IOConsole.cc

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

@@ -37 +37 @@
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
+#include "ConsoleCommandManager.h"
 
 namespace orxonox
@@ -305 +306 @@
                 // the user typed 1-2 arguments, check what he tried to type and print a suitable error
                 std::string groupLC = getLowercase(this->getToken(0));
-                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().begin(); it_group != ConsoleCommand::getCommandsLC().end(); ++it_group)
+                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
                     if (it_group->first == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
@@ -327 +328 @@
 
         // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().begin(); it_group != ConsoleCommand::getCommandsLC().end(); ++it_group)
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
         {
             if (it_group->first != "")
@@ -345 +346 @@
 
         // now also iterate through all shortcuts and keep the best if it's better than the one found above.
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().find("");
-        if (it_group !=  ConsoleCommand::getCommandsLC().end())
+        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
+        if (it_group !=  ConsoleCommandManager::getInstance().getCommandsLC().end())
         {
             for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); ++it_name)

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

@@ -34 +34 @@
 #include "CommandExecutor.h"
 
-#include "ConsoleCommand.h"
+#include "ConsoleCommandIncludes.h"
 #include "TclBind.h"
 #include "Shell.h"
@@ -155 +155 @@
 
         // assign the fallback-command to get hints about the possible commands and groups
-        evaluation.hintCommand_ = ConsoleCommand::getCommand(__CC_CommandExecutor_name, __CC_autocomplete_name);
+        evaluation.hintCommand_ = ConsoleCommandManager::getInstance().getCommand(__CC_CommandExecutor_name, __CC_autocomplete_name);
 
         // check if there's at least one argument
@@ -161 +161 @@
         {
             // try to get a command from the first token
-            evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0));
+            evaluation.execCommand_ = ConsoleCommandManager::getInstance().getCommandLC(evaluation.getToken(0));
             if (evaluation.execCommand_)
                 evaluation.execArgumentsOffset_ = 1;
@@ -167 +167 @@
             {
                 // try to get a command from the first two tokens
-                evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0), evaluation.getToken(1));
+                evaluation.execCommand_ = ConsoleCommandManager::getInstance().getCommandLC(evaluation.getToken(0), evaluation.getToken(1));
                 if (evaluation.execCommand_)
                     evaluation.execArgumentsOffset_ = 2;
@@ -288 +288 @@
 
             // check if the alias already exists - print an error and return if it does
-            if ((tokens.size() == 1 && ConsoleCommand::getCommand(tokens[0])) || (tokens.size() == 2 && ConsoleCommand::getCommand(tokens[0], tokens[1])))
+            if ((tokens.size() == 1 && ConsoleCommandManager::getInstance().getCommand(tokens[0])) || (tokens.size() == 2 && ConsoleCommandManager::getInstance().getCommand(tokens[0], tokens[1])))
             {
                 orxout(user_error) << "A command with name \"" << alias << "\" already exists." << endl;
@@ -296 +296 @@
             // create a new console command with the given alias as its name
             if (tokens.size() == 1)
-                createConsoleCommand(tokens[0], executor);
+                ConsoleCommandManager::getInstance().registerCommand(new ConsoleCommand(tokens[0], executor));
             else if (tokens.size() == 2)
-                createConsoleCommand(tokens[0], tokens[1], executor);
+                ConsoleCommandManager::getInstance().registerCommand(new ConsoleCommand(tokens[0], tokens[1], executor));
             else
                 orxout(user_error) << "\"" << alias << "\" is not a valid alias name (must have one or two words)." << endl;

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

@@ -35 +35 @@
 
 #include "util/Convert.h"
-#include "util/StringUtils.h"
 #include "core/Language.h"
 #include "core/GameMode.h"
 #include "core/input/KeyBinder.h"
 #include "core/input/KeyBinderManager.h"
+#include "ConsoleCommandManager.h"
 
 namespace orxonox
 {
     /**
-        @brief Constructor: Initializes all values and registers the command.
+        @brief Constructor: Initializes all values and registers the command (without a group).
+        @param name The name of the command
+        @param executor The executor of the command
+        @param bInitialized If true, the executor is used for both, the definition of the function-header AND to executute the command. If false, the command is inactive and needs to be assigned a function before it can be used.
+    */
+    ConsoleCommand::ConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized)
+    {
+        this->init("", name, executor, bInitialized);
+    }
+
+    /**
+        @brief Constructor: Initializes all values and registers the command (with a group).
         @param group The group of the command
         @param name The name of the command
@@ -52 +63 @@
     ConsoleCommand::ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized)
     {
+        this->init(group, name, executor, bInitialized);
+    }
+
+    void ConsoleCommand::init(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized)
+    {
         this->bActive_ = true;
         this->bHidden_ = false;
@@ -68 +84 @@
             this->executor_ = executor;
 
-        ConsoleCommand::registerCommand(group, name, this);
+        this->names_.push_back(CommandName(group, name));
     }
 
@@ -76 +92 @@
     ConsoleCommand::~ConsoleCommand()
     {
-        ConsoleCommand::unregisterCommand(this);
     }
 
@@ -84 +99 @@
     ConsoleCommand& ConsoleCommand::addShortcut()
     {
-        ConsoleCommand::registerCommand("", this->baseName_, this);
+        this->names_.push_back(CommandName("", this->baseName_));
         return *this;
     }
@@ -93 +108 @@
     ConsoleCommand& ConsoleCommand::addShortcut(const std::string&  name)
     {
-        ConsoleCommand::registerCommand("", name, this);
+        this->names_.push_back(CommandName("", name));
         return *this;
     }
@@ -102 +117 @@
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group)
     {
-        ConsoleCommand::registerCommand(group, this->baseName_, this);
+        this->names_.push_back(CommandName(group, this->baseName_));
         return *this;
     }
@@ -111 +126 @@
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group, const std::string&  name)
     {
-        ConsoleCommand::registerCommand(group, name, this);
+        this->names_.push_back(CommandName(group, name));
         return *this;
     }
@@ -587 +602 @@
         return *this;
     }
-
-    /**
-        @brief Returns the command with given group an name.
-        @param group The group of the requested command
-        @param name The group of the requested command
-        @param bPrintError If true, an error is printed if the command doesn't exist
-    */
-    /* static */ ConsoleCommand* ConsoleCommand::getCommand(const std::string& group, const std::string& name, bool bPrintError)
-    {
-        // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMap().find(group);
-        if (it_group != ConsoleCommand::getCommandMap().end())
-        {
-            // find the name
-            std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(name);
-            if (it_name != it_group->second.end())
-            {
-                // return the pointer
-                return it_name->second;
-            }
-        }
-        if (bPrintError)
-        {
-            if (group == "")
-                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
-            else
-                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
-        }
-        return 0;
-    }
-
-    /**
-        @brief Returns the command with given group an name in lowercase.
-        @param group The group of the requested command in lowercase
-        @param name The group of the requested command in lowercase
-        @param bPrintError If true, an error is printed if the command doesn't exist
-    */
-    /* static */ ConsoleCommand* ConsoleCommand::getCommandLC(const std::string& group, const std::string& name, bool bPrintError)
-    {
-        std::string groupLC = getLowercase(group);
-        std::string nameLC = getLowercase(name);
-
-        // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMapLC().find(groupLC);
-        if (it_group != ConsoleCommand::getCommandMapLC().end())
-        {
-            // find the name
-            std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(nameLC);
-            if (it_name != it_group->second.end())
-            {
-                // return the pointer
-                return it_name->second;
-            }
-        }
-        if (bPrintError)
-        {
-            if (group == "")
-                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
-            else
-                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
-        }
-        return 0;
-    }
-
-    /**
-        @brief Returns the static map that stores all console commands.
-    */
-    /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMap()
-    {
-        static std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMap;
-        return commandMap;
-    }
-
-    /**
-        @brief Returns the static map that stores all console commands in lowercase.
-    */
-    /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMapLC()
-    {
-        static std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMapLC;
-        return commandMapLC;
-    }
-
-    /**
-        @brief Registers a new command with given group an name by adding it to the command map.
-    */
-    /* static */ void ConsoleCommand::registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command)
-    {
-        if (name == "")
-            return;
-
-        // check if a command with this name already exists
-        if (ConsoleCommand::getCommand(group, name) != 0)
-        {
-            if (group == "")
-                orxout(internal_warning, context::commands) << "A console command with shortcut \"" << name << "\" already exists." << endl;
-            else
-                orxout(internal_warning, context::commands) << "A console command with name \"" << name << "\" already exists in group \"" << group << "\"." << endl;
-        }
-        else
-        {
-            // add the command to the map
-            ConsoleCommand::getCommandMap()[group][name] = command;
-            ConsoleCommand::getCommandMapLC()[getLowercase(group)][getLowercase(name)] = command;
-        }
-    }
-
-    /**
-        @brief Removes the command from the command map.
-    */
-    /* static */ void ConsoleCommand::unregisterCommand(ConsoleCommand* command)
-    {
-        // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMap().begin(); it_group != ConsoleCommand::getCommandMap().end(); )
-        {
-            // iterate through all commands of each group
-            for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
-            {
-                // erase the command
-                if (it_name->second == command)
-                    it_group->second.erase(it_name++);
-                else
-                    ++it_name;
-            }
-
-            // erase the group if it is empty now
-            if (it_group->second.empty())
-                ConsoleCommand::getCommandMap().erase(it_group++);
-            else
-                ++it_group;
-        }
-
-        // now the same for the lowercase-map:
-
-        // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMapLC().begin(); it_group != ConsoleCommand::getCommandMapLC().end(); )
-        {
-            // iterate through all commands of each group
-            for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
-            {
-                // erase the command
-                if (it_name->second == command)
-                    it_group->second.erase(it_name++);
-                else
-                    ++it_name;
-            }
-
-            // erase the group if it is empty now
-            if (it_group->second.empty())
-                ConsoleCommand::getCommandMapLC().erase(it_group++);
-            else
-                ++it_group;
-        }
-    }
-
-    /**
-        @brief Deletes all commands
-    */
-    /* static */ void ConsoleCommand::destroyAll()
-    {
-        // delete entries until the map is empty
-        while (!ConsoleCommand::getCommandMap().empty() && !ConsoleCommand::getCommandMap().begin()->second.empty())
-            delete ConsoleCommand::getCommandMap().begin()->second.begin()->second;
-    }
 }

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

@@ -28 +28 @@
 
 /**
-    @defgroup ConsoleCommand Console commands
-    @ingroup Command
-*/
-
-/**
     @file
     @ingroup Command ConsoleCommand
-    @brief Declaration of the orxonox::ConsoleCommand class and the SetConsoleCommand() macro.
-
-    @anchor ConsoleCommandExample
-
-    Console commands can be used to write scripts, use key-bindings or simply to be
-    entered into the shell by the user. Instances of orxonox::ConsoleCommand define
-    the function of a command, and also more information like, for example, if it is
-    active, default values, and possible arguments.
-
-    Commands need to be registered to the system statically on startup by using the
-    SetConsoleCommand() or DeclareConsoleCommand() macros outside of a function.
-    This ensures that commands are known to the system at any time, so they can be
-    evaluated (see orxonox::CommandExecutor::evaluate()), for example for key-bindings.
-
-    Example:
-    @code
-    void myCoutFunction(const std::string& text)        // Define a static function
-    {
-        orxout() << "Text: " << text << endl;           // Print the text to the console
-    }
-
-    SetConsoleCommand("cout", &myCoutFunction);         // Register the function as command with name "cout"
-    @endcode
-
-    Now you can open the shell and execute the command:
-    @code
-    $ cout Hello World
-    @endcode
-
-    Internally this command is now passed to orxonox::CommandExecutor::execute():
-    @code
-    CommandExecutor::execute("cout HelloWorld");
-    @endcode
-
-    CommandExecutor searches for a command with name "cout" and passes the arguments
-    "Hello World" to it. Because we registered myCoutFunction() with this command,
-    as a result the following text will be printed to the console:
-    @code
-    Text: Hello World
-    @endcode
-
-    You can add more attributes to the ConsoleCommand, by using the command-chain feature
-    of SetConsoleCommand(). For example like this:
-    @code
-    SetConsoleCommand("cout", &myCoutFunction)
-        .addGroup("output", "text")
-        .accessLevel(AccessLevel::Offline)
-        .defaultValues("no text");
-    @endcode
-
-    Open the shell again and try it:
-    @code
-    $ cout Hello World
-    Text: Hello World
-    $ output text Hello World
-    Text: Hello World
-    $ cout
-    Text: no text
-    @endcode
-
-    If you execute it online (note: the access level is "Offline"), you will see the
-    following (or something similar):
-    @code
-    $ cout Hello World
-    Error: Can't execute command "cout", access denied.
-    @endcode
-
-    If a command is executed, the arguments are passed to an underlying function,
-    whitch is wrapped by an orxonox::Functor which again is wrapped by an orxonox::Executor.
-    The Functor contains the function-pointer, as well as the object-pointer in
-    case of a non-static member-function. The executor stores possible default-values
-    for each argument of the function.
-
-    The function of a command can be changed at any time. It's possible to just exchange
-    the function-pointer of the underlying Functor if the headers of the functions are
-    exactly the same. But you can also exchange the Functor itself or even completely
-    replace the Executor. Also the other attributes of a ConsoleCommand can be modified
-    during the game, for example it can be activated or deactivated.
-
-    To do so, the function ModifyConsoleCommand() has to be used. It returns an instance
-    of orxonox::ConsoleCommand::ConsoleCommandManipulator which has an interface similar to
-    orxonox::ConsoleCommand, but with slight differences. You can use it the same way like
-    SetConsoleCommand(), meaning you can use command-chains to change different attributes at
-    the same time. ModifyConsoleCommand() must not be executed statically, but rather in a
-    function at some point of the execution of the program.
-
-    Example:
-    @code
-    void myOtherCoutFunction(const std::string& text)                       // Define a new static function
-    {
-        orxout() << "Uppercase: " << getUppercase(text) << endl;            // Print the text in uppercase to the console
-    }
-
-    {
-        // ...                                                              // somewhere in the code
-
-        ModifyConsoleCommand("cout").setFunction(&myOtherCoutFunction);     // Modify the underlying function of the command
-
-        // ...
-    }
-    @endcode
-
-    If you now enter the command into the shell, you'll see a different behavior:
-    @code
-    $ cout Hello World
-    Uppercase: HELLO WORLD
-    $ cout
-    Uppercase: NO TEXT
-    @endcode
-
-    A few important notes about changing functions:
-
-    Instead of changing the function with setFunction(), you can also create a command-stack
-    by using pushFunction() and popFunction(). It's important to note a few things about that,
-    because the underlying structure of Executor and Functor has a few pitfalls:
-     - If you push a new function-pointer, the same executor as before will be used (and, if
-       the headers match, even the same functor can be used, which is very fast)
-     - If you push a new Functor, the same executor as before will be used
-     - If you push a new Executor, everything is changed
-
-    Note that the executor contains the @b default @b values, so if you just exchange the
-    Functor, the default values remain the same. However if you decide to change the default
-    values at any point of the stack, <b>this will also change the default values on all
-    other stack-levels</b> that share the same executor. If you don't like this behavior,
-    you have to explicitly push a new executor before changing the default values, either by
-    calling pushFunction(executor) or by calling pushFunction(void) which pushes a copy of
-    the current executor to the stack.
-
-    Another important point are object pointers in case of non-static member-functions.
-    Whenever you set or push a new function, <b>you must add the object pointer again</b>
-    because objects are stored in the Functor which is usually exchanged if you change
-    the function.
-
-    You can also use a stack for objects, but note that this <b>object-stack is different for each
-    function</b> - so if you set a new function, the object-stack will be cleared. If you push
-    a new function, the old object-stack is stored in the stack, so it can be restored if
-    you pop the function.
-
-    %DeclareConsoleCommand():
-
-    Appart from SetConsoleCommand() you can also call DeclareConsoleCommand(). In contrast
-    to SetConsoleCommand(), this doesn't assign a function to the command. Indeed you have
-    to pass a function-pointer to DeclareConsoleCommand(), but it is only used to determine
-    the header of the future command-function. This allows to declare a command statically,
-    thus it's possible to evaluate key-bindings of this command, but the actual function
-    can be assigned at a later point.
-
-    Example:
-    @code
-    DeclareConsoleCommand("cout", &prototype::void__string);
-    @endcode
-
-    If you try to execute the command now, you see the following (or something similar):
-    @code
-    $ cout Hello World
-    Error: Can't execute command "cout", command is not active.
-    @endcode
-
-    You first have to assign a function to use the command:
-    @code
-    {
-        // ...
-
-        ModifyConsoleCommand("cout").setFunction(&myCoutFunction);
-
-        // ...
-    }
-    @endcode
-
-    Now you can use it:
-    @code
-    $ cout Hello World
-    Text: Hello World
-    @endcode
-
-    Note that the initial function prototype::void__string is defined in the namespace
-    orxonox::prototype. If there's no function with the desired header, you can extend
-    the collection of functions or simply use another function that has the same header.
+    @brief Declaration of the orxonox::ConsoleCommand class.
 */
 
@@ -223 +41 @@
 #include <vector>
 
-#include "util/VA_NARGS.h"
 #include "ArgumentCompletionFunctions.h"
 #include "Executor.h"
-
-
-/**
-    @brief Defines a console command. The macro is overloaded for 2-4 parameters.
-
-    This is an overloaded macro. Depending on the number of arguments a different
-    overloaded implementation of the macro will be chosen.
-
-    Console commands created with SetConsoleCommand() become active immediately and
-    the given function-pointer (and optionally the object) will be used to execute
-    the command.
-*/
-#define SetConsoleCommand(...) \
-    BOOST_PP_EXPAND(BOOST_PP_CAT(SetConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
-/**
-    @brief This macro is executed if you call SetConsoleCommand() with 2 arguments.
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of the corresponding command-function
-*/
-#define SetConsoleCommand2(name, functionpointer) \
-    SetConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
-/**
-    @brief This macro is executed if you call SetConsoleCommand() with 3 arguments.
-    @param group The group (string) of the console command
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of the corresponding command-function
-*/
-#define SetConsoleCommand3(group, name, functionpointer) \
-    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
-/**
-    @brief This macro is executed if you call SetConsoleCommand() with 4 arguments.
-    @param group The group (string) of the console command
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of the corresponding command-function
-    @param object The object that will be assigned to the command. Used for member-functions.
-*/
-#define SetConsoleCommand4(group, name, functionpointer, object) \
-    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
-
-/// Internal macro
-#define SetConsoleCommandGeneric(group, name, functor) \
-    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __UNIQUE_NUMBER__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor)))
-
-
-/**
-    @brief Declares a console command. The macro is overloaded for 2-3 parameters.
-
-    This is an overloaded macro. Depending on the number of arguments a different
-    overloaded implementation of the macro will be chosen.
-
-    Console commands created with DeclareConsoleCommand() don't use the the given
-    function-pointer to execute the command, it is only used to define the header
-    of the future command-function. The command is inactive until you manually
-    set a function with orxonox::ModifyConsoleCommand(). You can use a different
-    function-pointer than in the final command, as long as it has the same header.
-*/
-#define DeclareConsoleCommand(...) \
-    BOOST_PP_EXPAND(BOOST_PP_CAT(DeclareConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
-/**
-    @brief This macro is executed if you call DeclareConsoleCommand() with 2 arguments.
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of an arbitrary function that has the same header as the final function
-*/
-#define DeclareConsoleCommand2(name, functionpointer) \
-    DeclareConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
-/**
-    @brief This macro is executed if you call DeclareConsoleCommand() with 3 arguments.
-    @param group The group (string) of the console command
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of an arbitrary function that has the same header as the final function
-*/
-#define DeclareConsoleCommand3(group, name, functionpointer) \
-    DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
-
-/// Internal macro
-#define DeclareConsoleCommandGeneric(group, name, functor) \
-    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __UNIQUE_NUMBER__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor), false))
-
 
 namespace orxonox
@@ -365 +104 @@
 
         public:
+            /**
+             * @brief Defines the name of a command, consisting of an optional group ("" means no group) and the name itself.
+             */
+            struct CommandName
+            {
+                CommandName(const std::string& group, const std::string& name) : group_(group), name_(name) {}
+                std::string group_;
+                std::string name_;
+            };
+
             /**
                 @brief Helper class that is used to manipulate console commands.
@@ -522 +271 @@
 
         public:
+            ConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true);
             ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true);
             ~ConsoleCommand();
@@ -620 +370 @@
                 { return this; }
 
+            inline const std::vector<CommandName>& getNames()
+                { return this->names_; }
+
         private:
+            void init(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized);
+
             bool headersMatch(const FunctorPtr& functor);
             bool headersMatch(const ExecutorPtr& executor);
@@ -641 +396 @@
             AccessLevel::Enum accessLevel_;                                 ///< The access level (the state of the game in which you can access the command)
             std::string baseName_;                                          ///< The name that was first assigned to the command
+            std::vector<CommandName> names_;                                ///< All names and aliases of this command
             FunctorPtr baseFunctor_;                                        ///< The functor that defines the header of the command-function
 
@@ -655 +411 @@
             LanguageEntryLabel descriptionReturnvalue_;                     ///< A description of the return-value
             LanguageEntryLabel descriptionParam_[MAX_FUNCTOR_ARGUMENTS];    ///< A description for each argument
-
-        public:
-            /// Returns the map with all groups and commands.
-            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
-                { return ConsoleCommand::getCommandMap(); }
-            /// Returns the map with all groups and commands in lowercase.
-            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
-                { return ConsoleCommand::getCommandMapLC(); }
-
-            /// Returns a command (shortcut) with given name. @param name The name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
-            static inline ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
-                { return ConsoleCommand::getCommand("", name, bPrintError); }
-            /// Returns a command (shortcut) with given name in lowercase. @param name The lowercase name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
-            static inline ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
-                { return ConsoleCommand::getCommandLC("", name, bPrintError); }
-
-            static ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
-            static ConsoleCommand* getCommandLC(const std::string& group, const std::string& name, bool bPrintError = false);
-
-            static void destroyAll();
-
-        private:
-            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMap();
-            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMapLC();
-
-            static void registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command);
-            static void unregisterCommand(ConsoleCommand* command);
     };
-
-    /**
-        @brief Creates a new ConsoleCommand.
-        @param name The name of the command
-        @param executor The executor of the command
-        @param bInitialized If true, the command is ready to be executed, otherwise it has to be activated first.
-    */
-    inline ConsoleCommand* createConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
-        { return new ConsoleCommand("", name, executor, bInitialized); }
-    /**
-        @brief Creates a new ConsoleCommand.
-        @param group The group of the command
-        @param name The name of the command
-        @param executor The executor of the command
-        @param bInitialized If true, the command is ready to be executed, otherwise it has to be activated first.
-    */
-    inline ConsoleCommand* createConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
-        { return new ConsoleCommand(group, name, executor, bInitialized); }
-
-
-    /**
-        @brief Returns a manipulator for a command with the given name.
-
-        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
-        but it can still be used without checks, because all functions of ConsoleCommandManipulator
-        check internally if the command exists.
-    */
-    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& name)
-        { return ConsoleCommand::getCommand(name, true); }
-    /**
-        @brief Returns a manipulator for a command with the given group and name.
-
-        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
-        but it can still be used without checks, because all functions of ConsoleCommandManipulator
-        check internally if the command exists.
-    */
-    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& group, const std::string& name)
-        { return ConsoleCommand::getCommand(group, name, true); }
 }
 

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

@@ -41 +41 @@
 #include "util/ExprParser.h"
 #include "util/StringUtils.h"
-#include "ConsoleCommand.h"
+#include "ConsoleCommandIncludes.h"
 #include "CommandExecutor.h"
 

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

@@ -39 +39 @@
 #include "util/Exception.h"
 #include "util/StringUtils.h"
-#include "ConsoleCommand.h"
+#include "ConsoleCommandIncludes.h"
 #include "TclThreadManager.h"
 

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

@@ -42 +42 @@
 #include "core/config/ConfigFileManager.h"
 #include "core/config/ConfigValueIncludes.h"
-#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
 #include "core/input/InputBuffer.h"
 #include "CommandExecutor.h"
@@ -84 +84 @@
 
         // Choose the default level according to the path Orxonox was started (build directory or not)
-        OutputLevel defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        OutputLevel defaultDebugLevel = (ApplicationPaths::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
         this->setLevelMax(defaultDebugLevel);
 
@@ -164 +164 @@
     void Shell::devModeChanged(bool value)
     {
-        bool isNormal = (value == PathConfig::buildDirectoryRun());
+        bool isNormal = (value == ApplicationPaths::buildDirectoryRun());
         if (isNormal)
         {

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

@@ -49 +49 @@
 
 #include "util/output/BaseWriter.h"
-#include "core/Core.h"
+#include "core/CoreConfig.h"
 
 namespace orxonox

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

@@ -37 +37 @@
 #include "util/Exception.h"
 #include "util/StringUtils.h"
-#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
 #include "CommandExecutor.h"
-#include "ConsoleCommand.h"
+#include "ConsoleCommandIncludes.h"
 #include "TclThreadManager.h"
 
@@ -143 +143 @@
     {
 #ifdef DEPENDENCY_PACKAGE_ENABLE
-        if (PathConfig::buildDirectoryRun())
+        if (ApplicationPaths::buildDirectoryRun())
             return (std::string(specialConfig::dependencyLibraryDirectory) + "/tcl");
         else
-            return (PathConfig::getRootPathString() + specialConfig::defaultLibraryPath + "/tcl");
+            return (ApplicationPaths::getRootPathString() + specialConfig::defaultLibraryPath + "/tcl");
 #else
         return "";

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

@@ -47 +47 @@
 #include "core/CoreIncludes.h"
 #include "CommandExecutor.h"
-#include "ConsoleCommand.h"
+#include "ConsoleCommandIncludes.h"
 #include "TclBind.h"
 #include "TclThreadList.h"