Changeset 947 for code/branches/core2/src/orxonox/core

Timestamp:

Mar 28, 2008, 10:13:58 PM (17 years ago)

Author:

landauf

Message:

• added CommandExecutor
• added ConsoleCommand macros
• added getTypename to all MultiTypes
• added 2 static maps to Identifier that contain all existing Identifiers with their names and lowercase names respectively.
• added 2 maps to each Identifier that contain all console commands of the Identifier with their names and lowercase names respectively
• using tolower(.) and toupper(.) instead of selfmade hacks in String.h
• added AccessLevel enum
• added some test-console-commands to OutputHandler, Ambient and SpaceShip

Location:

code/branches/core2/src/orxonox/core

Files:

• CMakeLists.txt (modified) (1 diff)
• CommandExecutor.cc (added)
• CommandExecutor.h (added)
• ConfigValueContainer.cc (modified) (1 diff)
• ConfigValueContainer.h (modified) (2 diffs)
• ConsoleCommand.h (added)
• CorePrereqs.h (modified) (1 diff)
• DebugLevel.cc (modified) (1 diff)
• Executor.cc (modified) (2 diffs)
• Executor.h (modified) (10 diffs)
• Functor.h (modified) (3 diffs)
• Identifier.cc (modified) (4 diffs)
• Identifier.h (modified) (11 diffs)
• OutputHandler.cc (modified) (1 diff)
• OutputHandler.h (modified) (1 diff)
• XMLPort.h (modified) (5 diffs)

code/branches/core2/src/orxonox/core/CMakeLists.txt

@@ -19 +19 @@
   Namespace.cc
   NamespaceNode.cc
+  CommandExecutor.cc
 )
 

code/branches/core2/src/orxonox/core/ConfigValueContainer.cc

@@ -181 +181 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseString(const std::string& input, MultiTypeMath& defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, const MultiTypeMath& defvalue)
     {
         if (defvalue.getType() == MT_int)

code/branches/core2/src/orxonox/core/ConfigValueContainer.h

@@ -102 +102 @@
             const std::string& getDescription() const;
 
-            bool parseString(const std::string& input, MultiTypeMath& defvalue);
+            bool parseString(const std::string& input, const MultiTypeMath& defvalue = MT_null);
             bool valueToString(std::string* output, MultiTypeMath& input);
             void resetConfigFileEntry();
@@ -110 +110 @@
             static bool isEmpty(const std::string& line);
             static bool isComment(const std::string& line);
+
+            inline std::string getTypename() const
+                { return this->value_.getTypename(); }
 
         private:

code/branches/core2/src/orxonox/core/CorePrereqs.h

@@ -91 +91 @@
   class ClassTreeMaskIterator;
   class ClassTreeMaskNode;
+  class CommandExecutor;
   class ConfigValueContainer;
   class DebugLevel;
   class Error;
   class Executor;
+  template <class T>
+  class ExecutorMember;
+  class ExecutorStatic;
   class Factory;
+  class Functor;
+  template <class T>
+  class FunctorMember;
+  class FunctorStatic;
   class Identifier;
   class IdentifierDistributor;

code/branches/core2/src/orxonox/core/DebugLevel.cc

@@ -95 +95 @@
 
         // Return a constant value while we're creating the object
-        return 4;
+        return 5;
     }
 }

code/branches/core2/src/orxonox/core/Executor.cc

@@ -32 +32 @@
 namespace orxonox
 {
-    Executor::Executor(Functor* functor, const std::string& name)
+    Executor::Executor(Functor* functor, const std::string& name, AccessLevel::Level level)
     {
         this->functor_ = functor;
         this->name_ = name;
+        this->accessLevel_ = level;
+
         this->bAddedDescription_ = false;
         this->bAddedDescriptionReturnvalue_ = false;
@@ -60 +62 @@
     {
         EXECUTOR_PARSE(normal);
-    }
-
-    void Executor::setName(const std::string name)
-    {
-        this->name_ = name;
-    }
-
-    const std::string& Executor::getName() const
-    {
-        return this->name_;
     }
 

code/branches/core2/src/orxonox/core/Executor.h

@@ -129 +129 @@
     return true
 
+namespace AccessLevel
+{
+    enum Level
+    {
+        None,
+        User,
+        Admin,
+        Offline,
+        Debug,
+        Disabled
+    };
+}
 
 namespace orxonox
@@ -135 +147 @@
     {
         public:
-            Executor(Functor* functor, const std::string& name = "");
+            Executor(Functor* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None);
             virtual ~Executor();
 
@@ -153 +165 @@
             bool parse(const std::string& params, const std::string& delimiter = " ") const;
 
-            void setName(const std::string name);
-            const std::string& getName() const;
-
             void setDescription(const std::string& description);
             const std::string& getDescription() const;
@@ -165 +174 @@
             const std::string& getDescriptionReturnvalue(int param) const;
 
-            inline int getParamCount() const
+            inline unsigned int getParamCount() const
                 { return this->functor_->getParamCount(); }
             inline bool hasReturnvalue() const
@@ -173 +182 @@
             inline MultiTypeMath getReturnvalue() const
                 { return this->functor_->getReturnvalue(); }
-            inline std::string getTypenameParam(int param) const
+            inline std::string getTypenameParam(unsigned int param) const
                 { return this->functor_->getTypenameParam(param); }
             inline std::string getTypenameReturnvalue() const
                 { return this->functor_->getTypenameReturnvalue(); }
+
+            inline void setName(const std::string name)
+                { this->name_ = name; }
+            inline const std::string& getName() const
+                { return this->name_; }
+
+            inline void setAccessLevel(AccessLevel::Level level)
+                { this->accessLevel_ = level; }
+            inline AccessLevel::Level getAccessLevel() const
+                { return this->accessLevel_; }
 
             void setDefaultValues(const MultiTypeMath& param1);
@@ -186 +205 @@
 
             bool allDefaultValuesSet() const;
+            inline bool defaultValueSet(unsigned int index) const
+            {
+                if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
+                    return this->bAddedDefaultValue_[index];
+
+                return false;
+            }
 
         protected:
@@ -201 +227 @@
             bool bAddedDescriptionReturnvalue_;
             bool bAddedDescriptionParam_[MAX_FUNCTOR_ARGUMENTS];
+
+            AccessLevel::Level accessLevel_;
     };
 
@@ -206 +234 @@
     {
         public:
-            ExecutorStatic(FunctorStatic* functor, const std::string& name = "") : Executor(functor, name) {}
+            ExecutorStatic(FunctorStatic* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None) : Executor(functor, name, level) {}
             virtual ~ExecutorStatic() {}
     };
@@ -214 +242 @@
     {
         public:
-            ExecutorMember(FunctorMember<T>* functor, const std::string& name = "") : Executor(functor, name) {}
+            ExecutorMember(FunctorMember<T>* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None) : Executor(functor, name, level) {}
             virtual ~ExecutorMember() {}
 
@@ -260 +288 @@
     };
 
-    inline Executor* createExecutor(Functor* functor, const std::string& name = "")
-    {
-        return new Executor(functor, name);
+    inline Executor* createExecutor(Functor* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None)
+    {
+        return new Executor(functor, name, level);
     }
 
     template <class T>
-    inline ExecutorMember<T>* createExecutor(FunctorMember<T>* functor, const std::string& name = "")
-    {
-        return new ExecutorMember<T>(functor, name);
+    inline ExecutorMember<T>* createExecutor(FunctorMember<T>* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None)
+    {
+        return new ExecutorMember<T>(functor, name, level);
     }
 
-    inline ExecutorStatic* createExecutor(FunctorStatic* functor, const std::string& name = "")
-    {
-        return new ExecutorStatic(functor, name);
+    inline ExecutorStatic* createExecutor(FunctorStatic* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None)
+    {
+        return new ExecutorStatic(functor, name, level);
     }
 }

code/branches/core2/src/orxonox/core/Functor.h

@@ -37 +37 @@
 #define MAX_FUNCTOR_ARGUMENTS 5
 
-enum FunctionType
+namespace orxonox
 {
-    FT_MEMBER,
-    FT_CONSTMEMBER,
-    FT_STATIC
-};
-
-
-template <class T>
-inline std::string typeToString();
+    enum FunctionType
+    {
+        FT_MEMBER,
+        FT_CONSTMEMBER,
+        FT_STATIC
+    };
+
+
+    template <class T>
+    inline std::string typeToString() { return "unknown"; }
 
 #define CreateTypeToStringTemplate(type) \
@@ -52 +54 @@
     inline std::string typeToString<type>() { return #type; }
 
-CreateTypeToStringTemplate(int);
-CreateTypeToStringTemplate(unsigned int);
-CreateTypeToStringTemplate(char);
-CreateTypeToStringTemplate(unsigned char);
-CreateTypeToStringTemplate(short);
-CreateTypeToStringTemplate(unsigned short);
-CreateTypeToStringTemplate(long);
-CreateTypeToStringTemplate(unsigned long);
-CreateTypeToStringTemplate(float);
-CreateTypeToStringTemplate(double);
-CreateTypeToStringTemplate(long double);
-CreateTypeToStringTemplate(bool);
-CreateTypeToStringTemplate(std::string);
-CreateTypeToStringTemplate(orxonox::Vector2);
-CreateTypeToStringTemplate(orxonox::Vector3);
-CreateTypeToStringTemplate(orxonox::Quaternion);
-CreateTypeToStringTemplate(orxonox::ColourValue);
-CreateTypeToStringTemplate(orxonox::Radian);
-CreateTypeToStringTemplate(orxonox::Degree);
-
-
-class _CoreExport Functor
-{
-    public:
-        Functor() {}
-        virtual ~Functor() {}
-
-        virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-
-        inline unsigned int getParamCount() const { return this->numParams_; }
-        inline bool hasReturnvalue() const { return this->hasReturnValue_; }
-        inline FunctionType getType() const { return this->type_; }
-        inline MultiTypeMath getReturnvalue() const { return this->returnedValue_; }
-
-        std::string getTypenameParam(int param) const { return (param > 0 && param <= 5) ? this->typeParam_[param-1] : ""; }
-        std::string getTypenameReturnvalue() const { return this->typeReturnvalue_; }
-
-    protected:
-        unsigned int numParams_;
-        bool hasReturnValue_;
-        FunctionType type_;
-        MultiTypeMath returnedValue_;
-
-        std::string typeReturnvalue_;
-        std::string typeParam_[MAX_FUNCTOR_ARGUMENTS];
-};
-
-class _CoreExport FunctorStatic : public Functor
-{
-    public:
-        virtual ~FunctorStatic() {}
-        virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-};
-
-template <class T>
-class FunctorMember : public Functor
-{
-    public:
-        FunctorMember()
-        {
-            constObject_ = 0;
-            object_ = 0;
-            bConstObject_ = false;
-        }
-        virtual ~FunctorMember() {}
-
-        virtual void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-        virtual void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-
-        virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
-        {
-            if (this->bConstObject_)
+    CreateTypeToStringTemplate(int);
+    CreateTypeToStringTemplate(unsigned int);
+    CreateTypeToStringTemplate(char);
+    CreateTypeToStringTemplate(unsigned char);
+    CreateTypeToStringTemplate(short);
+    CreateTypeToStringTemplate(unsigned short);
+    CreateTypeToStringTemplate(long);
+    CreateTypeToStringTemplate(unsigned long);
+    CreateTypeToStringTemplate(float);
+    CreateTypeToStringTemplate(double);
+    CreateTypeToStringTemplate(long double);
+    CreateTypeToStringTemplate(bool);
+    CreateTypeToStringTemplate(std::string);
+    CreateTypeToStringTemplate(orxonox::Vector2);
+    CreateTypeToStringTemplate(orxonox::Vector3);
+    CreateTypeToStringTemplate(orxonox::Quaternion);
+    CreateTypeToStringTemplate(orxonox::ColourValue);
+    CreateTypeToStringTemplate(orxonox::Radian);
+    CreateTypeToStringTemplate(orxonox::Degree);
+
+
+    class _CoreExport Functor
+    {
+        public:
+            Functor() {}
+            virtual ~Functor() {}
+
+            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+
+            inline unsigned int getParamCount() const { return this->numParams_; }
+            inline bool hasReturnvalue() const { return this->hasReturnValue_; }
+            inline FunctionType getType() const { return this->type_; }
+            inline MultiTypeMath getReturnvalue() const { return this->returnedValue_; }
+
+            std::string getTypenameParam(unsigned int param) const { return (param > 0 && param <= 5) ? this->typeParam_[param-1] : ""; }
+            std::string getTypenameReturnvalue() const { return this->typeReturnvalue_; }
+
+        protected:
+            unsigned int numParams_;
+            bool hasReturnValue_;
+            FunctionType type_;
+            MultiTypeMath returnedValue_;
+
+            std::string typeReturnvalue_;
+            std::string typeParam_[MAX_FUNCTOR_ARGUMENTS];
+    };
+
+    class _CoreExport FunctorStatic : public Functor
+    {
+        public:
+            virtual ~FunctorStatic() {}
+            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+    };
+
+    template <class T>
+    class FunctorMember : public Functor
+    {
+        public:
+            FunctorMember()
             {
-                if (this->constObject_)
-                    (*this)(this->constObject_, param1, param2, param3, param4, param5);
+                constObject_ = 0;
+                object_ = 0;
+                bConstObject_ = false;
+            }
+            virtual ~FunctorMember() {}
+
+            virtual void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+            virtual void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+
+            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+            {
+                if (this->bConstObject_)
+                {
+                    if (this->constObject_)
+                        (*this)(this->constObject_, param1, param2, param3, param4, param5);
+                    else
+                    {
+                        COUT(1) << "An error occurred in Functor.h:" << std::endl;
+                        COUT(1) << "Error: No const object set." << std::endl;
+                    }
+                }
                 else
                 {
-                    COUT(1) << "An error occurred in Functor.h:" << std::endl;
-                    COUT(1) << "Error: No const object set." << std::endl;
+                    if (this->object_)
+                        (*this)(this->object_, param1, param2, param3, param4, param5);
+                    else
+                    {
+                        COUT(1) << "An error occurred in Functor.h:" << std::endl;
+                        COUT(1) << "Error: No object set." << std::endl;
+                    }
                 }
             }
-            else
+
+            void setObject(T* object)
             {
-                if (this->object_)
-                    (*this)(this->object_, param1, param2, param3, param4, param5);
-                else
-                {
-                    COUT(1) << "An error occurred in Functor.h:" << std::endl;
-                    COUT(1) << "Error: No object set." << std::endl;
-                }
+                this->bConstObject_ = false;
+                this->object_ = object;
             }
-        }
-
-        void setObject(T* object)
-        {
-            this->bConstObject_ = false;
-            this->object_ = object;
-        }
-
-        void setObject(const T* object)
-        {
-            this->bConstObject_ = true;
-            this->constObject_ = object;
-        }
-
-    private:
-        const T* constObject_;
-        T* object_;
-        bool bConstObject_;
-};
+
+            void setObject(const T* object)
+            {
+                this->bConstObject_ = true;
+                this->constObject_ = object;
+            }
+
+        private:
+            const T* constObject_;
+            T* object_;
+            bool bConstObject_;
+    };
 
 
@@ -403 +405 @@
 
 
-CREATE_ALL_STATIC_FUNCTORS();
-CREATE_ALL_MEMBER_FUNCTORS();
+    CREATE_ALL_STATIC_FUNCTORS();
+    CREATE_ALL_MEMBER_FUNCTORS();
+}
 
 #endif /* _Functor_H__ */

code/branches/core2/src/orxonox/core/Identifier.cc

@@ -35 +35 @@
 #include "Identifier.h"
 #include "Factory.h"
+#include "Executor.h"
+#include "CommandExecutor.h"
 
 namespace orxonox
@@ -50 +52 @@
         this->bCreatedOneObject_ = false;
         this->factory_ = 0;
+
+        this->bHasConfigValues_ = false;
+        this->bHasConsoleCommands_ = false;
 
         this->children_ = new std::set<const Identifier*>();
@@ -198 +203 @@
 
     /**
+        @brief Returns the map that stores all Identifiers.
+        @return The map
+    */
+    std::map<std::string, Identifier*>& Identifier::getIdentifierMapIntern()
+    {
+        static std::map<std::string, Identifier*> identifierMap;
+        return identifierMap;
+    }
+
+    /**
+        @brief Returns the map that stores all Identifiers.
+        @return The map
+    */
+    std::map<std::string, Identifier*>& Identifier::getLowercaseIdentifierMapIntern()
+    {
+        static std::map<std::string, Identifier*> lowercaseIdentifierMap;
+        return lowercaseIdentifierMap;
+    }
+
+    /**
+        @brief Adds the ConfigValueContainer of a variable, given by the string of its name.
+        @param varname The name of the variablee
+        @param container The container
+    */
+    void Identifier::addConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
+    {
+        this->bHasConfigValues_ = true;
+        this->configValues_[varname] = container;
+        this->configValues_LC_[getLowercase(varname)] = container;
+    }
+
+    /**
         @brief Returns the ConfigValueContainer of a variable, given by the string of its name.
         @param varname The name of the variable
@@ -212 +249 @@
 
     /**
-        @brief Adds the ConfigValueContainer of a variable, given by the string of its name.
-        @param varname The name of the variablee
-        @param container The container
-    */
-    void Identifier::addConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
-    {
-        this->configValues_[varname] = container;
-    }
-
+        @brief Returns the ConfigValueContainer of a variable, given by the string of its name in lowercase.
+        @param varname The name of the variable in lowercase
+        @return The ConfigValueContainer
+    */
+    ConfigValueContainer* Identifier::getLowercaseConfigValueContainer(const std::string& varname)
+    {
+        std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_LC_.find(varname);
+        if (it != configValues_LC_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds a new console command of this class.
+        @param executor The executor of the command
+        @param bCreateShortcut If this is true a shortcut gets created so you don't have to add the classname to access this command
+        @return The executor of the command
+    */
+    ExecutorStatic& Identifier::addConsoleCommand(ExecutorStatic* executor, bool bCreateShortcut)
+    {
+        this->bHasConsoleCommands_ = true;
+        this->consoleCommands_[executor->getName()] = executor;
+        this->consoleCommands_LC_[getLowercase(executor->getName())] = executor;
+
+        if (bCreateShortcut)
+            CommandExecutor::addConsoleCommandShortcut(executor);
+
+        return (*executor);
+    }
+
+    /**
+        @brief Returns the executor of a console command with given name.
+        @brief name The name of the requested console command
+        @return The executor of the requested console command
+    */
+    ExecutorStatic* Identifier::getConsoleCommand(const std::string& name) const
+    {
+        std::map<std::string, ExecutorStatic*>::const_iterator it = this->consoleCommands_.find(name);
+        if (it != this->consoleCommands_.end())
+            return (*it).second;
+        else
+            return 0;
+    }
+
+    /**
+        @brief Returns the executor of a console command with given name in lowercase.
+        @brief name The name of the requested console command in lowercae
+        @return The executor of the requested console command
+    */
+    ExecutorStatic* Identifier::getLowercaseConsoleCommand(const std::string& name) const
+    {
+        std::map<std::string, ExecutorStatic*>::const_iterator it = this->consoleCommands_LC_.find(name);
+        if (it != this->consoleCommands_LC_.end())
+            return (*it).second;
+        else
+            return 0;
+    }
+
+    /**
+        @brief Lists the names of all Identifiers in a std::set<const Identifier*>.
+        @param out The outstream
+        @param list The list (or set) of Identifiers
+        @return The outstream
+    */
     std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list)
     {

code/branches/core2/src/orxonox/core/Identifier.h

@@ -62 +62 @@
 #include "Debug.h"
 #include "Iterator.h"
+#include "util/String.h"
 
 namespace orxonox
@@ -114 +115 @@
             inline const std::string& getName() const { return this->name_; }
 
+
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
             inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
@@ -142 +144 @@
             inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
 
+
+            /** @brief Returns the map that stores all Identifiers. @return The map */
+            static inline const std::map<std::string, Identifier*>& getIdentifierMap() { return Identifier::getIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapBegin() { return Identifier::getIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapEnd() { return Identifier::getIdentifierMap().end(); }
+
+            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
+            static inline const std::map<std::string, Identifier*>& getLowercaseIdentifierMap() { return Identifier::getLowercaseIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapBegin() { return Identifier::getLowercaseIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapEnd() { return Identifier::getLowercaseIdentifierMap().end(); }
+
+
+            /** @brief Returns the map that stores all config values. @return The const_iterator */
+            inline const std::map<std::string, ConfigValueContainer*>& getConfigValueMap() const { return this->configValues_; }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all config values. @return The const_iterator */
+            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapBegin() const { return this->configValues_.begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all config values. @return The const_iterator */
+            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapEnd() const { return this->configValues_.end(); }
+
+            /** @brief Returns the map that stores all config values with their names in lowercase. @return The const_iterator */
+            inline const std::map<std::string, ConfigValueContainer*>& getLowercaseConfigValueMap() const { return this->configValues_LC_; }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all config values with their names in lowercase. @return The const_iterator */
+            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapBegin() const { return this->configValues_LC_.begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all config values with their names in lowercase. @return The const_iterator */
+            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
+
+
+            /** @brief Returns the map that stores all console commands. @return The const_iterator */
+            inline const std::map<std::string, ExecutorStatic*>& getConsoleCommandMap() const { return this->consoleCommands_; }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
+            inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
+            inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
+
+            /** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
+            inline const std::map<std::string, ExecutorStatic*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all console commands with their names in lowercase. @return The const_iterator */
+            inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all console commands with their names in lowercase. @return The const_iterator */
+            inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
+
+
+            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
+            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
+            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
+            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
+
             /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
             inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
@@ -151 +204 @@
             void setNetworkID(unsigned int id);
 
+            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
             ConfigValueContainer* getConfigValueContainer(const std::string& varname);
-            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
-
+            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
+
+            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
             virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
-            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
-
+
+            virtual void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container) = 0;
             virtual XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname) = 0;
-            virtual void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container) = 0;
+
+            ExecutorStatic& addConsoleCommand(ExecutorStatic* executor, bool bCreateShortcut);
+            ExecutorStatic* getConsoleCommand(const std::string& name) const;
+            ExecutorStatic* getLowercaseConsoleCommand(const std::string& name) const;
+
+        protected:
+            /** @brief Returns the map that stores all Identifiers. @return The map */
+            static std::map<std::string, Identifier*>& getIdentifierMapIntern();
+            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
+            static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
 
         private:
@@ -189 +253 @@
             }
 
-            std::set<const Identifier*> parents_;                      //!< The parents of the class the Identifier belongs to
-            std::set<const Identifier*>* children_;                    //!< The children of the class the Identifier belongs to
-
-            std::set<const Identifier*> directParents_;                //!< The direct parents of the class the Identifier belongs to
-            std::set<const Identifier*>* directChildren_;              //!< The direct children of the class the Identifier belongs to
-
-            std::string name_;                                          //!< The name of the class the Identifier belongs to
-
-            BaseFactory* factory_;                                      //!< The Factory, able to create new objects of the given class (if available)
-            bool bCreatedOneObject_;                                    //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
-            static int hierarchyCreatingCounter_s;                      //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
-            unsigned int classID_;                                      //!< The network ID to identify a class through the network
-            std::map<std::string, ConfigValueContainer*> configValues_; //!< A map to link the string of configurable variables with their ConfigValueContainer
+            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
+            std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
+
+            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
+            std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
+
+            std::string name_;                                             //!< The name of the class the Identifier belongs to
+
+            BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
+            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
+            static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
+            unsigned int classID_;                                         //!< The network ID to identify a class through the network
+
+            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
+            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
+            std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
+
+            bool bHasConsoleCommands_;                                     //!< True if this class has at least one assigned console command
+            std::map<std::string, ExecutorStatic*> consoleCommands_;       //!< All console commands of this class
+            std::map<std::string, ExecutorStatic*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
     };
 
@@ -246 +317 @@
             ~ClassIdentifier() {}                                       // don't delete
 
-            ObjectList<T>* objects_;    //!< The ObjectList, containing all objects of type T
-            bool bSetName_;             //!< True if the name is set
-            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;
-            std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;
+            ObjectList<T>* objects_;                                                                    //!< The ObjectList, containing all objects of type T
+            bool bSetName_;                                                                             //!< True if the name is set
+            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;              //!< All loadable parameters
+            std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;   //!< All attachable objects
     };
 
@@ -300 +371 @@
             this->name_ = name;
             this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
         }
     }
@@ -324 +397 @@
     }
 
+    /**
+        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @return The container
+    */
     template <class T>
     XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
@@ -334 +412 @@
     }
 
+    /**
+        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @param container The container
+    */
     template <class T>
     void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
@@ -340 +423 @@
     }
 
+    /**
+        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @return The container
+    */
     template <class T>
     XMLPortObjectContainer* ClassIdentifier<T>::getXMLPortObjectContainer(const std::string& sectionname)
@@ -350 +438 @@
     }
 
+    /**
+        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @param container The container
+    */
     template <class T>
     void ClassIdentifier<T>::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)

code/branches/core2/src/orxonox/core/OutputHandler.cc

@@ -33 +33 @@
 #include "DebugLevel.h"
 #include "OutputHandler.h"
+#include "ConsoleCommand.h"
 
 namespace orxonox
 {
+    ConsoleCommandShortcutGeneric(log, createExecutor(createFunctor(&OutputHandler::log), "log", AccessLevel::None));
+
     /**
         @brief Constructor: Opens the logfile and writes the first line.

code/branches/core2/src/orxonox/core/OutputHandler.h

@@ -58 +58 @@
 
             static OutputHandler& getOutStream();
+
+            /** @brief Puts some text on the outstream. @param text The text */
+            static inline void log(const std::string& text)
+                { OutputHandler::getOutStream().output(text); }
 
             /** @brief Returns a reference to the logfile. @return The logfile */

code/branches/core2/src/orxonox/core/XMLPort.h

@@ -42 +42 @@
 
 #define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, createExecutor(createFunctor(&classname::loadfunction), #loadfunction), createExecutor(createFunctor(&classname::savefunction), #savefunction), xmlelement, mode)
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode)
 #define XMLPortParam_Template(classname, paramname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, createExecutor(createFunctor loadtemplate (&classname::loadfunction), #loadfunction), createExecutor(createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode)
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode)
 
 #define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, createExecutor(createFunctor(&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
 #define XMLPortParamLoadOnly_Template(classname, paramname, loadtemplate, loadfunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, createExecutor(createFunctor loadtemplate (&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
 
 #define XMLPortParamGeneric(containername, classname, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
@@ -62 +62 @@
 
 #define XMLPortObject(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
-    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, createExecutor(createFunctor(&classname::loadfunction), #loadfunction), createExecutor(createFunctor(&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
 #define XMLPortObject_Template(classname, objectclass, sectionname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
-    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, createExecutor(createFunctor loadtemplate (&classname::loadfunction), #loadfunction), createExecutor(createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
 
 #define XMLPortObjectGeneric(containername, classname, objectclass, sectionname, loadexecutor, saveexecutor, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
@@ -143 +143 @@
                 this->loadexecutor_ = loadexecutor;
                 this->saveexecutor_ = saveexecutor;
-
-                this->setDefaultValue_[0] = false;
-                this->setDefaultValue_[1] = false;
-                this->setDefaultValue_[2] = false;
-                this->setDefaultValue_[3] = false;
-                this->setDefaultValue_[4] = false;
             }
 
@@ -209 +203 @@
             virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param)
             {
-                if (!this->setDefaultValue_[index])
-                {
-                    this->setDefaultValue_[index] = true;
+                if (!this->loadexecutor_->defaultValueSet(index))
                     this->loadexecutor_->setDefaultValue(index, param);
-                }
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1)
             {
-                if (!this->setDefaultValue_[0])
-                {
-                    this->setDefaultValue_[0] = true;
+                if (!this->loadexecutor_->defaultValueSet(0))
                     this->loadexecutor_->setDefaultValues(param1);
-                }
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
             {
-                if ((!this->setDefaultValue_[0]) || (!this->setDefaultValue_[1]))
-                {
-                    this->setDefaultValue_[0] = true;
-                    this->setDefaultValue_[1] = true;
+                if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)))
                     this->loadexecutor_->setDefaultValues(param1, param2);
-                }
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
             {
-                if ((!this->setDefaultValue_[0]) || (!this->setDefaultValue_[1]) || (!this->setDefaultValue_[2]))
-                {
-                    this->setDefaultValue_[0] = true;
-                    this->setDefaultValue_[1] = true;
-                    this->setDefaultValue_[3] = true;
+                if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)))
                     this->loadexecutor_->setDefaultValues(param1, param2, param3);
-                }
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
             {
-                if ((!this->setDefaultValue_[0]) || (!this->setDefaultValue_[1]) || (!this->setDefaultValue_[2]) || (!this->setDefaultValue_[3]))
-                {
-                    this->setDefaultValue_[0] = true;
-                    this->setDefaultValue_[1] = true;
-                    this->setDefaultValue_[3] = true;
-                    this->setDefaultValue_[4] = true;
+                if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)))
                     this->loadexecutor_->setDefaultValues(param1, param2, param3, param4);
-                }
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
             virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
             {
-                if ((!this->setDefaultValue_[0]) || (!this->setDefaultValue_[1]) || (!this->setDefaultValue_[2]) || (!this->setDefaultValue_[3]) || (!this->setDefaultValue_[4]))
-                {
-                    this->setDefaultValue_[0] = true;
-                    this->setDefaultValue_[1] = true;
-                    this->setDefaultValue_[3] = true;
-                    this->setDefaultValue_[4] = true;
-                    this->setDefaultValue_[5] = true;
+                if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)) || (!this->loadexecutor_->defaultValueSet(4)))
                     this->loadexecutor_->setDefaultValues(param1, param2, param3, param4, param5);
-                }
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
@@ -276 +242 @@
             ExecutorMember<T>* saveexecutor_;
             ParseParams parseParams_;
-            bool setDefaultValue_[5];
     };