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

Timestamp:

Apr 12, 2008, 3:34:55 PM (17 years ago)

Author:

landauf

Message:

extracted all config-value related macros from CoreIncludes.h and moved them to ConfigValueIncludes.h.

ConfigValueContainer can now handle std::vector<x> where 'x' is is any type supported by MultiTypeMath (all primitives, pointer, string, vector2, vector3, quaternion, colourvalue, radian, degree).

the vectors size is currently limited to 256 elements. this is just a practical limit, it can be raised if it's necessary. the reason for the limit is: you can add new elements to a vector by simply typing 'set classname varname index value' into the console or adding a new entry in the config-file. if 'index' is bigger than the vectors size, all elements up to 'index' are inserted. if the user accidentally enters a big number, he could end up with >4*10^{9 elements in his config-file, resulting in 10-100gb on the hdd and a completely filled memory. and that's not exactly what i want}

Location:

code/branches/core2/src/orxonox/core

Files:

• CommandExecutor.cc (modified) (2 diffs)
• ConfigFileManager.cc (modified) (12 diffs)
• ConfigFileManager.h (modified) (6 diffs)
• ConfigValueContainer.cc (modified) (9 diffs)
• ConfigValueContainer.h (modified) (4 diffs)
• ConfigValueIncludes.h (added)
• CoreIncludes.h (modified) (3 diffs)
• DebugLevel.cc (modified) (1 diff)
• Language.cc (modified) (1 diff)
• OutputHandler.cc (modified) (1 diff)

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

@@ -29 +29 @@
 #include "ConsoleCommand.h"
 #include "util/String.h"
+#include "util/Convert.h"
 #include "Identifier.h"
 #include "Language.h"
@@ -1313 +1314 @@
     {
         AddLanguageEntry("CommandExecutor::oldvalue", "old value");
-        return "{" + container->getTypename() + "} (" + GetLocalisation("CommandExecutor::oldvalue") + ": " + container->toString() + ")";
+        if (!container->isVector())
+            return ("{" + container->getTypename() + "} (" + GetLocalisation("CommandExecutor::oldvalue") + ": " + container->toString() + ")");
+        else
+            return ("(vector<" + container->getTypename() + ">) (size: " + getConvertedValue<unsigned int, std::string>(container->getVectorSize()) + ")");
     }
 

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

@@ -49 +49 @@
     void cleanConfig()
     {
-        ConfigFileManager::getSingleton()->clean();
+        ConfigFileManager::getSingleton()->clean(false);
     }
 
@@ -76 +76 @@
 
     ///////////////////////////////
-    // ConfigFileEntryArrayValue //
+    // ConfigFileEntryVectorValue //
     ///////////////////////////////
-    std::string ConfigFileEntryArrayValue::getFileEntry() const
+    std::string ConfigFileEntryVectorValue::getFileEntry() const
     {
         if (this->additionalComment_ == "" || this->additionalComment_.size() == 0)
-            return (this->name_ + "[" + getConvertedValue<unsigned int, std::string>(this->index_, 0) + "]" + "=" + this->value_);
+            return (this->name_ + "[" + getConvertedValue<unsigned int, std::string>(this->index_, "0") + "]" + "=" + this->value_);
         else
-            return (this->name_ + "[" + getConvertedValue<unsigned int, std::string>(this->index_, 0) + "]=" + this->value_ + " " + this->additionalComment_);
+            return (this->name_ + "[" + getConvertedValue<unsigned int, std::string>(this->index_, "0") + "]=" + this->value_ + " " + this->additionalComment_);
     }
 
@@ -96 +96 @@
     }
 
+    void ConfigFileSection::deleteVectorEntries(const std::string& name, unsigned int startindex)
+    {
+        for (std::list<ConfigFileEntry*>::iterator it = this->entries_.begin(); it != this->entries_.end(); )
+        {
+            if (((*it)->getName() == name) && ((*it)->getIndex() >= startindex))
+            {
+                delete (*it);
+                this->entries_.erase(it++);
+            }
+            else
+            {
+                ++it;
+            }
+        }
+    }
+
+    unsigned int ConfigFileSection::getVectorSize(const std::string& name)
+    {
+        unsigned int size = 0;
+        for (std::list<ConfigFileEntry*>::const_iterator it = this->entries_.begin(); it != this->entries_.end(); ++it)
+            if ((*it)->getName() == name)
+                if ((*it)->getIndex() > size)
+                    size = (*it)->getIndex();
+        return (size + 1);
+    }
+
     std::string ConfigFileSection::getFileEntry() const
     {
@@ -124 +150 @@
 
         if (index == 0)
-            return this->entries_.insert(this->entries_.end(), (ConfigFileEntry*)(new ConfigFileEntryArrayValue(name, index, fallback)));
+            return this->entries_.insert(this->entries_.end(), (ConfigFileEntry*)(new ConfigFileEntryVectorValue(name, index, fallback)));
         else
-            return this->entries_.insert(this->getEntryIterator(name, index - 1), (ConfigFileEntry*)(new ConfigFileEntryArrayValue(name, index, fallback)));
+            return this->entries_.insert(++this->getEntryIterator(name, index - 1), (ConfigFileEntry*)(new ConfigFileEntryVectorValue(name, index, fallback)));
     }
 
@@ -173 +199 @@
             if (!isEmpty(temp) && !isComment(temp))
             {
-                unsigned int pos1 = line.find('[');
-                unsigned int pos2 = line.find(']');
+                unsigned int   pos1 = temp.find('[');
+                if (pos1 == 0) pos1 = line.find('['); else pos1 = std::string::npos;
+                unsigned int   pos2 = line.find(']');
 
                 if (pos1 != std::string::npos && pos2 != std::string::npos && pos2 > pos1 + 1)
                 {
                     // New section
-                    std::string comment = temp.substr(pos2 + 1);
+                    std::string comment = line.substr(pos2 + 1);
                     if (isComment(comment))
                         newsection = new ConfigFileSection(line.substr(pos1 + 1, pos2 - pos1 - 1), comment);
@@ -232 +259 @@
                             {
                                 // New array
-                                newsection->getEntries().insert(newsection->getEntries().end(), new ConfigFileEntryArrayValue(getStripped(line.substr(0, pos2)), index, value, comment));
+                                std::list<ConfigFileEntry*>::iterator it = newsection->getEntryIterator(getStripped(line.substr(0, pos2)), index, value);
+                                (*it)->setValue(value);
+                                (*it)->setComment(comment);
                                 continue;
                             }
@@ -284 +313 @@
     }
 
-    void ConfigFile::clean()
+    void ConfigFile::clean(bool bCleanComments)
     {
         for (std::list<ConfigFileSection*>::iterator it1 = this->sections_.begin(); it1 != this->sections_.end(); )
@@ -292 +321 @@
             {
                 // The section exists, delete comment
-                (*it1)->setComment("");
+                if (bCleanComments)
+                    (*it1)->setComment("");
                 for (std::list<ConfigFileEntry*>::iterator it3 = (*it1)->entries_.begin(); it3 != (*it1)->entries_.end(); )
                 {
@@ -299 +329 @@
                     {
                         // The config-value exists, delete comment
-                        (*it3)->setComment("");
+                        if (bCleanComments)
+                            (*it3)->setComment("");
                         ++it3;
                     }
@@ -331 +362 @@
         this->bUpdated_ = true;
 
-        return (*this->sections_.insert(this->sections_.begin(), new ConfigFileSection(section)));
+        return (*this->sections_.insert(this->sections_.end(), new ConfigFileSection(section)));
     }
 
@@ -400 +431 @@
     }
 
-    void ConfigFileManager::clean()
+    void ConfigFileManager::clean(bool bCleanComments)
     {
         for(std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); ++it)
-            this->clean((*it).first);
+            this->clean((*it).first, bCleanComments);
     }
 
@@ -417 +448 @@
     }
 
-    void ConfigFileManager::clean(ConfigFileType type)
-    {
-        this->getFile(type)->clean();
-        this->getFile(type)->save();
+    void ConfigFileManager::clean(ConfigFileType type, bool bCleanComments)
+    {
+        this->getFile(type)->clean(bCleanComments);
     }
 

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

@@ -107 +107 @@
 
     ///////////////////////////////
-    // ConfigFileEntryArrayValue //
+    // ConfigFileEntryVectorValue //
     ///////////////////////////////
-    class _CoreExport ConfigFileEntryArrayValue : public ConfigFileEntryValue
-    {
-        public:
-            inline ConfigFileEntryArrayValue(const std::string& name, unsigned int index, const std::string& value = "", const std::string& additionalComment = "") : ConfigFileEntryValue(name, value, additionalComment), index_(index) {}
-            inline virtual ~ConfigFileEntryArrayValue() {}
+    class _CoreExport ConfigFileEntryVectorValue : public ConfigFileEntryValue
+    {
+        public:
+            inline ConfigFileEntryVectorValue(const std::string& name, unsigned int index, const std::string& value = "", const std::string& additionalComment = "") : ConfigFileEntryValue(name, value, additionalComment), index_(index) {}
+            inline virtual ~ConfigFileEntryVectorValue() {}
 
             inline virtual unsigned int getIndex() const
@@ -179 +179 @@
             inline const std::string& getValue(const std::string& name, unsigned int index, const std::string& fallback)
                 { return this->getEntry(name, index, fallback)->getValue(); }
+
+            void deleteVectorEntries(const std::string& name, unsigned int startindex = 0);
+            unsigned int getVectorSize(const std::string& name);
 
             std::string getFileEntry() const;
@@ -216 +219 @@
             void load(bool bCreateIfNotExisting = true);
             void save() const;
-            void clean();
+            void clean(bool bCleanComments = false);
 
             inline void setValue(const std::string& section, const std::string& name, const std::string& value)
@@ -228 +231 @@
                 { const std::string& output = this->getSection(section)->getValue(name, index, fallback); this->saveIfUpdated(); return output; }
 
+            inline void deleteVectorEntries(const std::string& section, const std::string& name, unsigned int startindex = 0)
+                { this->getSection(section)->deleteVectorEntries(name, startindex); }
+            inline unsigned int getVectorSize(const std::string& section, const std::string& name)
+                { return this->getSection(section)->getVectorSize(name); }
+
         private:
             ConfigFileSection* getSection(const std::string& section);
@@ -250 +258 @@
             void load(bool bCreateIfNotExisting = true);
             void save();
-            void clean();
+            void clean(bool bCleanComments = false);
 
             void load(ConfigFileType type, bool bCreateIfNotExisting = true);
             void save(ConfigFileType type);
-            void clean(ConfigFileType type);
+            void clean(ConfigFileType type, bool bCleanComments = false);
 
             inline void setValue(ConfigFileType type, const std::string& section, const std::string& name, const std::string& value)
@@ -266 +274 @@
                 { return this->getFile(type)->getValue(section, name, index, fallback); }
 
+            inline void deleteVectorEntries(ConfigFileType type, const std::string& section, const std::string& name, unsigned int startindex = 0)
+                { this->getFile(type)->deleteVectorEntries(section, name, startindex); }
+            inline unsigned int getVectorSize(ConfigFileType type, const std::string& section, const std::string& name)
+                { return this->getFile(type)->getVectorSize(section, name); }
+
             void updateConfigValues() const;
             void updateConfigValues(ConfigFileType type) const;

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

@@ -35 +35 @@
 #include "ConfigValueContainer.h"
 #include "Language.h"
+#include "util/SubString.h"
+#include "util/Convert.h"
+
+#define MAX_VECTOR_INDEX 255 // to avoid up to 4*10^9 vector entries in the config file after accidentally using a wrong argument
 
 
@@ -41 +45 @@
     /**
         @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
+        @param type The type of the corresponding config-file
+        @param identifier The identifier of the class the variable belongs to
         @param varname The name of the variable
         @param defvalue The default-value
     */
-    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, MultiTypeMath defvalue)
+    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const MultiTypeMath& defvalue)
     {
         this->type_ = type;
@@ -55 +59 @@
         this->value_ = defvalue;
         this->bAddedDescription_ = false;
+        this->bIsVector_ = false;
 
         this->defvalueString_ = defvalue.toString();
         this->update();
+    }
+
+    /**
+        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
+        @param type The type of the corresponding config-file
+        @param identifier The identifier of the class the variable belongs to
+        @param varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<MultiTypeMath>& defvalue)
+    {
+        this->type_ = type;
+        this->identifier_ = identifier;
+        this->sectionname_ = identifier->getName();
+        this->varname_ = varname;
+
+        this->valueVector_ = defvalue;
+        this->bAddedDescription_ = false;
+        this->bIsVector_ = true;
+
+        if (defvalue.size() > 0)
+            this->value_ = defvalue[0];
+
+        for (unsigned int i = 0; i < defvalue.size(); i++)
+            ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, defvalue[i].toString());
+
+        for (unsigned int i = 0; i < defvalue.size(); i++)
+            this->defvalueStringVector_.push_back(defvalue[i].toString());
+
+        this->update();
+    }
+
+    /**
+        @brief Adds a new entry to the end of the vector.
+        @param input The new entry
+        @return True if the new entry was successfully added
+    */
+    bool ConfigValueContainer::add(const std::string& input)
+    {
+        if (this->bIsVector_)
+            return this->set(this->valueVector_.size(), input);
+
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        return false;
+    }
+
+    /**
+        @brief Removes an existing entry from the vector.
+        @param index The index of the entry
+        @return True if the entry was removed
+    */
+    bool ConfigValueContainer::remove(unsigned int index)
+    {
+        if (this->bIsVector_)
+        {
+            if (index < this->valueVector_.size())
+            {
+                this->valueVector_.erase(this->valueVector_.begin() + index);
+                for (unsigned int i = index; i < this->valueVector_.size(); i++)
+                    ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i]);
+                ConfigFileManager::getSingleton()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->valueVector_.size());
+
+                return true;
+            }
+            COUT(1) << "Error: Invalid vector-index." << std::endl;
+        }
+
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        return false;
     }
 
@@ -67 +141 @@
     bool ConfigValueContainer::set(const std::string& input)
     {
+        if (this->bIsVector_)
+        {
+            SubString token(input, " ", "", true, '"', false, '(', ')', false, '\0');
+            int index = -1;
+            bool success = false;
+
+            if (token.size() > 0)
+                success = ConvertValue(&index, token[0]);
+
+            if (!success || index < 0 || index > MAX_VECTOR_INDEX)
+            {
+                if (!success)
+                    COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is a vector." << std::endl;
+                else
+                    COUT(1) << "Error: Invalid vector-index." << std::endl;
+                return false;
+            }
+
+            if (token.size() >= 2)
+                return this->set(index, token.subSet(1).join());
+            else
+                return this->set(index, "");
+        }
+
         bool success = this->tset(input);
-        this->setLineInConfigFile(input);
+        ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, input);
         return success;
+    }
+
+    /**
+        @brief Assigns a new value to the config-value of all objects and writes the change into the config-file.
+        @param index The index in the vector
+        @param input The new value
+        @return True if the new value was successfully assigned
+    */
+    bool ConfigValueContainer::set(unsigned int index, const std::string& input)
+    {
+        if (this->bIsVector_)
+        {
+            bool success = this->tset(index, input);
+            ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, index, input);
+            return success;
+        }
+
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        return false;
     }
 
@@ -86 +203 @@
 
     /**
+        @brief Assigns a new value to the config-value of all objects, but doesn't change the config-file (t stands for temporary).
+        @param index The index in the vector
+        @param input The new value
+        @return True if the new value was successfully assigned
+    */
+    bool ConfigValueContainer::tset(unsigned int index, const std::string& input)
+    {
+        if (this->bIsVector_)
+        {
+            bool success = this->parse(index, input);
+            if (this->identifier_)
+                this->identifier_->updateConfigValues();
+            return success;
+        }
+
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        return false;
+    }
+
+    /**
         @brief Sets the value of the variable back to the default value and resets the config-file entry.
     */
     bool ConfigValueContainer::reset()
     {
-        return this->set(this->defvalueString_);
+        if (!this->bIsVector_)
+            return this->set(this->defvalueString_);
+        else
+        {
+            bool success = true;
+            for (unsigned int i = 0; i < this->defvalueStringVector_.size(); i++)
+                if (!this->set(i, this->defvalueStringVector_[i]))
+                    success = false;
+            ConfigFileManager::getSingleton()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->defvalueStringVector_.size());
+            return success;
+        }
     }
 
@@ -98 +245 @@
     void ConfigValueContainer::update()
     {
-        this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_));
+        if (!this->bIsVector_)
+            this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_));
+        else
+        {
+            this->valueVector_.clear();
+            for (unsigned int i = 0; i < ConfigFileManager::getSingleton()->getVectorSize(this->type_, this->sectionname_, this->varname_); i++)
+            {
+                this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i]));
+                this->valueVector_.push_back(this->value_);
+            }
+        }
     }
 
@@ -108 +265 @@
     bool ConfigValueContainer::parse(const std::string& input)
     {
+        if (this->bIsVector_)
+        {
+            SubString token(input, " ", "", true, '"', false, '(', ')', false, '\0');
+            int index = -1;
+            bool success = false;
+
+            if (token.size() > 0)
+                success = ConvertValue(&index, token[0]);
+
+            if (!success || index < 0 || index > MAX_VECTOR_INDEX)
+                return false;
+
+            if (token.size() >= 2)
+                return this->parse(index, token.subSet(1).join());
+            else
+                return this->parse(index, "");
+        }
+
         MultiTypeMath temp = this->value_;
         if (temp.fromString(input))
@@ -114 +289 @@
             return true;
         }
+        return false;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type of the associated variable and assigns it.
+        @param index The index in the vector
+        @param input The string to convert
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parse(unsigned int index, const std::string& input)
+    {
+        if (this->bIsVector_)
+        {
+            if (index >= this->valueVector_.size())
+            {
+                for (unsigned int i = this->valueVector_.size(); i <= index; i++)
+                {
+                    this->valueVector_.push_back(MultiTypeMath());
+                    ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i]);
+                }
+            }
+
+            MultiTypeMath temp = this->value_;
+            if (temp.fromString(input))
+            {
+                this->valueVector_[index] = temp;
+                return true;
+            }
+            return false;
+        }
+
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
         return false;
     }
@@ -125 +332 @@
     bool ConfigValueContainer::parse(const std::string& input, const MultiTypeMath& defvalue)
     {
-        MultiTypeMath temp = defvalue;
-        if (temp.fromString(input))
-        {
-            this->value_ = temp;
+        if (this->parse(input))
             return true;
-        }
-        else
-        {
-            this->value_ = defvalue;
+
+        this->value_ = defvalue;
+        return false;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type of the associated variable and assigns it.
+        @param index The index in the vector
+        @param input The string to convert
+        @param defvalue The default value to assign if the parsing fails
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parse(unsigned int index, const std::string& input, const MultiTypeMath& defvalue)
+    {
+        if (this->bIsVector_)
+        {
+            if (this->parse(index, input))
+                return true;
+
+            this->valueVector_[index] = defvalue;
             return false;
         }
-    }
-
-    /**
-        @brief Sets the corresponding entry in the config-file to a given value.
-    */
-    void ConfigValueContainer::setLineInConfigFile(const std::string& input)
-    {
-        ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, input);
-    }
-
-    /**
-        @brief Sets the corresponding entry in the config-file back to the default value.
-    */
-    void ConfigValueContainer::resetLineInConfigFile()
-    {
-        this->setLineInConfigFile(this->value_.toString());
+
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        return false;
     }
 

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

@@ -43 +43 @@
 #define _ConfigValueContainer_H__
 
-#include <list>
 #include <string>
+#include <vector>
 
 #include "CorePrereqs.h"
@@ -73 +73 @@
     {
         public:
-            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, MultiTypeMath defvalue);
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const MultiTypeMath& defvalue);
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<MultiTypeMath>& defvalue);
 
             /** @brief Returns the configured value. @param value This is only needed to determine the right type. @return The value */
@@ -79 +80 @@
             inline ConfigValueContainer& getValue(T* value)
                 { this->value_.getValue(value); return *this; }
+            template <typename T>
+            inline ConfigValueContainer& getValue(std::vector<T>* value)
+            {
+                value->clear();
+                for (unsigned int i = 0; i < this->valueVector_.size(); i++)
+                    value->push_back(this->valueVector_[i]);
+                return *this;
+            }
 
-            inline const std::string& getName()
+            inline const std::string& getName() const
                 { return this->varname_; }
+            inline bool isVector() const
+                { return this->bIsVector_; }
+            inline unsigned int getVectorSize() const
+                { return this->valueVector_.size(); }
 
             void description(const std::string& description);
             const std::string& getDescription() const;
 
+            bool add(const std::string& input);
+            bool remove(unsigned int index);
             bool set(const std::string& input);
             bool tset(const std::string& input);
@@ -102 +117 @@
             bool parse(const std::string& input, const MultiTypeMath& defvalue);
 
-            void setLineInConfigFile(const std::string& input);
-            void resetLineInConfigFile();
+            bool set(unsigned int index, const std::string& input);
+            bool tset(unsigned int index, const std::string& input);
+            bool parse(unsigned int index, const std::string& input);
+            bool parse(unsigned int index, const std::string& input, const MultiTypeMath& defvalue);
 
-            ConfigFileType      type_;                          //!< The type of the corresponding config-file
-            Identifier*         identifier_;                    //!< The identifier of the class
-            std::string         sectionname_;                   //!< The name of the class the variable belongs to
-            std::string         varname_;                       //!< The name of the variable
-            std::string         defvalueString_;                //!< The string of the default-variable
+            bool                       bIsVector_;                  //!< True if the container contains a std::vector
 
-            MultiTypeMath       value_;                         //!< The value
+            ConfigFileType             type_;                       //!< The type of the corresponding config-file
+            Identifier*                identifier_;                 //!< The identifier of the class
+            std::string                sectionname_;                //!< The name of the class the variable belongs to
+            std::string                varname_;                    //!< The name of the variable
+            std::string                defvalueString_;             //!< The string of the default-value
+            std::vector<std::string>   defvalueStringVector_;       //!< A vector, containg the strings of the default-values in case we're storing a vector
 
-            std::list<std::string>::iterator configFileLine_;   //!< An iterator, pointing to the entry of the variable in the config-file
+            MultiTypeMath              value_;                      //!< The value
+            std::vector<MultiTypeMath> valueVector_;                //!< A vector, containg the values in case we're storing a vector
 
-            bool bAddedDescription_;                            //!< True if a description was added
-            LanguageEntryLabel description_;                    //!< The description
+            bool                       bAddedDescription_;          //!< True if a description was added
+            LanguageEntryLabel         description_;                //!< The description
     };
 }

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

@@ -28 +28 @@
 /**
     @file CoreIncludes.h
-    @brief Definition of macros and typedefs.
+    @brief Definition of macros for Identifier and Factory.
 
     Every class needs the RegisterObject(class) macro in its constructor. If the class is an interface
@@ -40 +40 @@
 #define _CoreIncludes_H__
 
-#include "CorePrereqs.h"
-
-// All needed header-files
 #include "Identifier.h"
 #include "ClassManager.h"
 #include "Factory.h"
 #include "ClassFactory.h"
-#include "Iterator.h"
-#include "OrxonoxClass.h"
-#include "ConfigValueContainer.h"
-#include "ConfigFileManager.h"
 #include "Debug.h"
 
 
-// All needed macros
 /**
     @brief Intern macro, containing the common parts of RegisterObject and RegisterRootObject.
@@ -112 +104 @@
     orxonox::Factory::getIdentifier(StringOrInt)
 
-/**
-    @brief Assigns the value, defined in the config-file, to the variable (or the default-value, if there is no entry in the file).
-    @param varname The name of the variable
-    @param defvalue The default-value of the variable
-*/
-#define SetConfigValue(varname, defvalue) \
-    orxonox::ConfigValueContainer* container##varname = this->getIdentifier()->getConfigValueContainer(#varname); \
-    if (!container##varname) \
-    { \
-        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, this->getIdentifier(), #varname, varname = defvalue); \
-        this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
-    } \
-    container##varname->getValue(&varname)
-
-/**
-    @brief Sets the variable and the config-file entry back to the previously defined default-value.
-    @param varname The name of the variable
-*/
-#define ResetConfigValue(varname) \
-    orxonox::ConfigValueContainer* container##varname##reset = this->getIdentifier()->getConfigValueContainer(#varname); \
-    if (container##varname##reset) \
-    { \
-        container##varname##reset->reset(); \
-        container##varname##reset->getValue(&varname); \
-    } \
-    else \
-        COUT(2) << "Warning: Couldn't reset variable " << #varname << ", corresponding container doesn't exist." << std::endl
-
-/**
-    @brief Assigns the command, defined in the keybind-file, to the key-variable (or an empty string, if there is no entry in the file).
-    @param varname The name of the key-variable
-*/
-#define SetKeybind(keyname) \
-    orxonox::ConfigValueContainer* container##keyname = this->getIdentifier()->getConfigValueContainer(#keyname); \
-    if (!container##keyname) \
-    { \
-        container##keyname = new orxonox::ConfigValueContainer(CFT_Keybindings, this->getIdentifier(), #keyname, keyname = ""); \
-        this->getIdentifier()->addConfigValueContainer(#keyname, container##keyname); \
-    } \
-    container##keyname->getValue(&varname)
-
 #endif /* _CoreIncludes_H__ */

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

@@ -33 +33 @@
 #include "DebugLevel.h"
 #include "CoreIncludes.h"
+#include "ConfigValueIncludes.h"
 
 namespace orxonox

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

@@ -35 +35 @@
 #include "CoreIncludes.h"
 #include "Language.h"
+#include "ConfigValueIncludes.h"
 
 namespace orxonox

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

@@ -47 +47 @@
         this->logfilename_ = logfilename;
         this->logfile_.open(this->logfilename_.c_str(), std::fstream::out);
-        this->logfile_ << "Started log" << std::endl;
+        this->logfile_ << "Started log at yyyy/mm/dd hh:mm:ss" << std::endl;
         this->logfile_.flush();
     }