Changeset 1052

code/trunk/bin/levels/sample.oxw

-                      r1032
+                      r1052
+<Namespace name="test" />
+<Namespace name="blub" />
+<Namespace name="rofl" />
+<Namespace name="ns1">
+  <Namespace name="ns11">
+    <Namespace name="ns111">
+    </Namespace>
+    <Namespace name="ns112">
+    </Namespace>
+  </Namespace>
+  <Namespace name="ns12">
+    <Namespace name="ns121">
+    </Namespace>
+    <Namespace name="ns122">
+    </Namespace>
+  </Namespace>
+</Namespace>
+<Namespace name="ns1::ns12::ns121">
+  <Namespace name="ns1211">
+  </Namespace>
+</Namespace>
+<Namespace name="ns1::ns12::ns122::ns1221" />
 <!--
  <audio>
 …
 <Model position="-200,1000,500" scale="10" mesh="hoover_turbine.mesh" yawpitchroll="-90,-90,0" />
+<Namespace name="test" />
+<Namespace name="blub">
+</Namespace>
+<Namespace name="rofl">
+  <Namespace name="lol">
+  </Namespace>
+</Namespace>
+<Namespace name="ns1">
+  <Namespace name="ns11">
+    <Namespace name="ns111">
+      <Namespace name="ns1111">
+      </Namespace>
+    </Namespace>
+  </Namespace>
+  <Namespace name="ns13">
+  </Namespace>
+</Namespace>
+<Namespace name="ns1 ns2">
+  <Namespace name="abc" />
+</Namespace>
+<Namespace name="ns1::ns11 ns1::ns12 ns1::ns12::ns121">
+  <Namespace name="muhahaha" />
+</Namespace>
+<Namespace name="test">
+  <Namespace name="test" />
+</Namespace>
+<Namespace name="ns1::ns13">
+  <Namespace name="..::ns14" />
+  <Namespace name="..::..::ns3" />
+</Namespace>
+<Namespace name="AAA::BBB::..::CCC::..::DDD::..::BBB::BBBBBB::..::BBBBBBBBBBBBBBBBBBB::..::..::EEE" />
+<Namespace name="..::justatest" />
+<Namespace name="@file.oxw::anothertest" />
+<Namespace name="justonemoretest::@file.oxw::gagagaga" />
+<Namespace name="AAA::BBB, AAA::CCC; AAA::DDD,AAA::EEE">
+  <Namespace name="hax" />
+</Namespace>
 <?lua
 for i = 1, 226, 1

code/trunk/src/CMakeLists.txt

-                      r1024
+                      r1052
 ADD_SUBDIRECTORY(util)
 ADD_SUBDIRECTORY(orxonox/core)
 ADD_SUBDIRECTORY(audio)
 ADD_SUBDIRECTORY(network)
+#ADD_SUBDIRECTORY(audio)
+#ADD_SUBDIRECTORY(network)
 ADD_SUBDIRECTORY(orxonox)

code/trunk/src/asylum/orxonox/objects/Fighter.cc

r1032	r1052
38	38	#include "util/String2Number.h"
39	39	#include "core/CoreIncludes.h"
	40	#include "core/ConfigValueIncludes.h"
40	41	#include "GraphicsEngine.h"
41	42	#include "core/InputManager.h"

code/trunk/src/asylum/orxonox/objects/Test.h

r1024	r1052
30	30
31	31	#include "core/BaseObject.h"
	32	#include "core/CoreIncludes.h"
32	33
33	34	namespace orxonox

code/trunk/src/asylum/orxonox/objects/test2.cc

-                      r1024
+                      r1052
 #include "test3.h"
 #include "core/CoreIncludes.h"
+#include "core/Executor.h"
 namespace orxonox
 …
         this->usefullClass3_ = Class(Test3);
         timer1.setTimer(1, true, this, &Test2::timerFunction1);
         timer2.setTimer(5, true, this, &Test2::timerFunction2);
         timer3.setTimer(10, false, this, &Test2::timerFunction3);
+        timer1.setTimer(1, true, this, createExecutor(createFunctor(&Test2::timerFunction1)));
+        timer2.setTimer(5, true, this, createExecutor(createFunctor(&Test2::timerFunction2)));
+        timer3.setTimer(10, false, this, createExecutor(createFunctor(&Test2::timerFunction3)));
+    }

code/trunk/src/asylum/orxonox/objects/test3.cc

-                      r1024
+                      r1052
 #include "test3.h"
 #include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
 namespace orxonox
 …
         SetConfigValue(value_vector3_, Vector3(13, 26, 39));
         SetConfigValue(value_colourvalue_, ColourValue(1.0, 0.5, 0.25, 0.887));
+        SetConfigValueVector(vector_int_, std::vector<int>(1, 13));
+        SetConfigValueVector(vector_string_, std::vector<std::string>(3, "nothing"));
+        SetConfigValueVector(vector_vector3_, std::vector<Vector3>(1, Vector3(3, 2, 1)));
+    }
 …
     void Test3::configOutput()
+    {
+        std::cout << "int:         " << this->value_int_ << std::endl;
+        std::cout << "uint:        " << this->value_uint_ << std::endl;
+        std::cout << "char:        " << (int)this->value_char_ << std::endl;
+        std::cout << "uchar:       " << (int)this->value_uchar_ << std::endl;
+        std::cout << "float:       " << this->value_float_ << std::endl;
+        std::cout << "double:      " << this->value_double_ << std::endl;
+        std::cout << "bool:        " << this->value_bool_ << std::endl;
+        std::cout << "string:      " << this->value_string_ << std::endl;
+        std::cout << "constchar:   " << this->value_constchar_ << std::endl;
+        std::cout << "vector2:     " << this->value_vector2_ << std::endl;
+        std::cout << "vector3:     " << this->value_vector3_ << std::endl;
+        std::cout << "colourvalue: " << this->value_colourvalue_ << std::endl;
+        std::cout << "int:             " << this->value_int_ << std::endl;
+        std::cout << "uint:            " << this->value_uint_ << std::endl;
+        std::cout << "char:            " << (int)this->value_char_ << std::endl;
+        std::cout << "uchar:           " << (int)this->value_uchar_ << std::endl;
+        std::cout << "float:           " << this->value_float_ << std::endl;
+        std::cout << "double:          " << this->value_double_ << std::endl;
+        std::cout << "bool:            " << this->value_bool_ << std::endl;
+        std::cout << "string:         >" << this->value_string_ << "<" << std::endl;
+        std::cout << "constchar:      >" << this->value_constchar_ << "<" << std::endl;
+        std::cout << "vector2:         " << this->value_vector2_ << std::endl;
+        std::cout << "vector3:         " << this->value_vector3_ << std::endl;
+        std::cout << "colourvalue:     " << this->value_colourvalue_ << std::endl;
+        std::cout << std::endl;
+        for (unsigned int i = 0; i < this->vector_int_.size(); i++)
+        std::cout << "vector<int>:     " << i << ": " << this->vector_int_[i] << std::endl;
+        for (unsigned int i = 0; i < this->vector_string_.size(); i++)
+        std::cout << "vector<string>:  " << i << ":>" << this->vector_string_[i] << "<" << std::endl;
+        for (unsigned int i = 0; i < this->vector_vector3_.size(); i++)
+        std::cout << "vector<vector3>: " << i << ": " << this->vector_vector3_[i] << std::endl;
+        ModifyConfigValue(value_int_, tset, "100");
+        std::cout << std::endl;
+        std::cout << "int:             " << this->value_int_ << std::endl;
+        ModifyConfigValue(value_int_, update);
+        std::cout << std::endl;
+        std::cout << "int:             " << this->value_int_ << std::endl;
+    }

code/trunk/src/asylum/orxonox/objects/test3.h

-                      r1024
+                      r1052
 #ifndef _Test3_H__
 #define _Test3_H__
+#include <vector>
 #include "core/BaseObject.h"
 …
             Vector3             value_vector3_;
             ColourValue         value_colourvalue_;
+            std::vector<int>         vector_int_;
+            std::vector<std::string> vector_string_;
+            std::vector<Vector3>     vector_vector3_;
     };
+}

code/trunk/src/orxonox/GraphicsEngine.cc

-                      r1042
+                      r1052
 #include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
 #include "core/Debug.h"
 namespace orxonox {
-  using namespace Ogre;
   /**
 …
     this->renderWindow_ = 0;
     // delete the ogre log and the logManager (since we have created it).
     if (LogManager::getSingletonPtr() != 0)
+    {
       LogManager::getSingleton().getDefaultLog()->removeListener(this);
       LogManager::getSingleton().destroyLog(LogManager::getSingleton().getDefaultLog());
       delete LogManager::getSingletonPtr();
+    if (Ogre::LogManager::getSingletonPtr() != 0)
+    {
+      Ogre::LogManager::getSingleton().getDefaultLog()->removeListener(this);
+      Ogre::LogManager::getSingleton().destroyLog(Ogre::LogManager::getSingleton().getDefaultLog());
+      delete Ogre::LogManager::getSingletonPtr();
+    }
     COUT(4) << "*** GraphicsEngine: Destroying objects done" << std::endl;
 …
     //TODO: Check if file exists (maybe not here)
 /*#ifndef OGRE_STATIC_LIB
     root_ = new Root(configPath_ + "plugins.cfg", configPath_ + "ogre.cfg",
+    root_ = new Ogre::Root(configPath_ + "plugins.cfg", configPath_ + "ogre.cfg",
                      configPath_ + "Ogre.log");
 #else
     root_ = new Root(NULL, configPath_ + "ogre.cfg", configPath_ + "Ogre.log");
+    root_ = new Ogre::Root(NULL, configPath_ + "ogre.cfg", configPath_ + "Ogre.log");
 #endif*/
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC && defined(_DEBUG)
 …
     // Root will detect that we've already created a Log
     COUT(4) << "*** GraphicsEngine: Creating Ogre Root..." << std::endl;
     root_ = new Root(plugin_filename);
+    root_ = new Ogre::Root(plugin_filename);
     COUT(4) << "*** GraphicsEngine: Creating Ogre Root done" << std::endl;
+  }
 …
    * @return scene manager
    */
   SceneManager* GraphicsEngine::getSceneManager()
+  Ogre::SceneManager* GraphicsEngine::getSceneManager()
+  {
     if(!scene_)
+    {
       scene_ = root_->createSceneManager(ST_GENERIC, "Default SceneManager");
+      scene_ = root_->createSceneManager(Ogre::ST_GENERIC, "Default SceneManager");
       COUT(3) << "Info: Created SceneMan: " << scene_ << std::endl;
+    }
 …
+  {
     this->renderWindow_ = root_->initialise(true, "OrxonoxV2");
     TextureManager::getSingleton().setDefaultNumMipmaps(5);
+    Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
     //TODO: Do NOT load all the groups, why are we doing that? And do we really do that? initialise != load...
     ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+    Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+  }
 …
     //TODO: Work with ressource groups (should be generated by a special loader)
     // Load resource paths from data file using configfile ressource type
     ConfigFile cf;
+    Ogre::ConfigFile cf;
     cf.load(dataPath + "resources.cfg");
     // Go through all sections & settings in the file
     ConfigFile::SectionIterator seci = cf.getSectionIterator();
+    Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
     std::string secName, typeName, archName;
 …
+    {
       secName = seci.peekNextKey();
       ConfigFile::SettingsMultiMap *settings = seci.getNext();
       ConfigFile::SettingsMultiMap::iterator i;
+      Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
+      Ogre::ConfigFile::SettingsMultiMap::iterator i;
       for (i = settings->begin(); i != settings->end(); ++i)
+      {
 …
         archName = i->second; // name (and location) of archive
         ResourceGroupManager::getSingleton().addResourceLocation(
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
                                            std::string(dataPath + archName),
                                            typeName, secName);
 …
   */
   void GraphicsEngine::messageLogged(const std::string& message,
     LogMessageLevel lml, bool maskDebug, const std::string &logName)
+    Ogre::LogMessageLevel lml, bool maskDebug, const std::string &logName)
+  {
     int orxonoxLevel;
     switch (lml)
+    {
       case LML_TRIVIAL:
+      case Ogre::LML_TRIVIAL:
         orxonoxLevel = this->ogreLogLevelTrivial_;
         break;
       case LML_NORMAL:
+      case Ogre::LML_NORMAL:
         orxonoxLevel = this->ogreLogLevelNormal_;
         break;
       case LML_CRITICAL:
+      case Ogre::LML_CRITICAL:
         orxonoxLevel = this->ogreLogLevelCritical_;
         break;

code/trunk/src/orxonox/Orxonox.cc

-                      r1039
+                      r1052
 // core
+#include "core/ConsoleCommand.h"
 #include "core/Debug.h"
 #include "core/Factory.h"
 #include "core/Loader.h"
 #include "core/Tickable.h"
+#include "core/InputBuffer.h"
 #include "core/InputManager.h"
 …
 namespace orxonox
+{
+  ConsoleCommand(Orxonox, exit, AccessLevel::None, true);
+  ConsoleCommand(Orxonox, slomo, AccessLevel::Offline, true).setDefaultValue(0, 1.0);
+  ConsoleCommand(Orxonox, setTimeFactor, AccessLevel::Offline, false).setDefaultValue(0, 1.0);
+  class Testconsole : public InputBufferListener
+  {
+    public:
+      Testconsole(InputBuffer* ib) : ib_(ib) {}
+      void listen() const
+      {
+        std::cout << "> " << this->ib_->get() << std::endl;
+      }
+      void execute() const
+      {
+        std::cout << ">> " << this->ib_->get() << std::endl;
+        if (!CommandExecutor::execute(this->ib_->get()))
+          std::cout << "Error" << std::endl;
+        this->ib_->clear();
+      }
+      void hintandcomplete() const
+      {
+        std::cout << CommandExecutor::hint(this->ib_->get()) << std::endl;
+        this->ib_->set(CommandExecutor::complete(this->ib_->get()));
+      }
+      void clear() const
+      {
+        this->ib_->clear();
+      }
+      void removeLast() const
+      {
+        this->ib_->removeLast();
+      }
+    private:
+      InputBuffer* ib_;
+  };
   /**
     @brief Reference to the only instance of the class.
 …
+  {
     COUT(2) << "initialising server" << std::endl;
     ogre_->setConfigPath(path);
     ogre_->setup();
     //root_ = ogre_->getRoot();
     if(!ogre_->load(this->dataPath_)) abortImmediate(/* unable to load */);
     server_g = new network::Server();
+  }
 …
+  {
     COUT(2) << "initialising client" << std::endl;\
     ogre_->setConfigPath(path);
     ogre_->setup();
 …
     if(!ogre_->load(this->dataPath_)) abortImmediate(/* unable to load */);
+  }
   void Orxonox::standaloneInit(std::string path)
+  {
     COUT(2) << "initialising standalone mode" << std::endl;
     ogre_->setConfigPath(path);
     ogre_->setup();
 …
     if(!ogre_->load(this->dataPath_)) abortImmediate(/* unable to load */);
+  }
   /**
    * start modules
 …
+    }
+  }
   void Orxonox::clientStart(){
     ogre_->initialise();
     Factory::createClassHierarchy();
     auMan_ = new audio::AudioManager();
     //bulletMgr_ = new BulletManager();
     Ogre::Overlay* hudOverlay = Ogre::OverlayManager::getSingleton().getByName("Orxonox/HUD1.2");
     HUD* orxonoxHud;
 …
     orxonoxHud->setEnergyDistr(20,20,60);
     hudOverlay->show();
     client_g->establishConnection();
     client_g->tick(0);
     //setupInputSystem();
     startRenderLoop();
+  }
   void Orxonox::serverStart(){
     //TODO: start modules
 …
     createScene();
     setupInputSystem();
     server_g->open();
     startRenderLoop();
+  }
   void Orxonox::standaloneStart(){
     //TODO: start modules
 …
     createScene();
     setupInputSystem();
     startRenderLoop();
+  }
 …
   void Orxonox::startRenderLoop()
+  {
+    InputBuffer* ib = new InputBuffer();
+    Testconsole* console = new Testconsole(ib);
+    ib->registerListener(console, &Testconsole::listen, true);
+    ib->registerListener(console, &Testconsole::execute, '\r', false);
+    ib->registerListener(console, &Testconsole::hintandcomplete, '\t', true);
+    ib->registerListener(console, &Testconsole::clear, '§', true);
+    ib->registerListener(console, &Testconsole::removeLast, '\b', true);
     // first check whether ogre root object has been created
     if (Ogre::Root::getSingletonPtr() == 0)
 …
       // Iterate through all Tickables and call their tick(dt) function
       for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; )
         (it++)->tick((float)evt.timeSinceLastFrame);
+        (it++)->tick((float)evt.timeSinceLastFrame * this->timefactor_);
       // don't forget to call _fireFrameStarted in ogre to make sure

code/trunk/src/orxonox/Orxonox.h

-                      r1039
+                      r1052
       static void destroySingleton();
+      static inline void slomo(float factor) { Orxonox::getSingleton()->timefactor_ = factor; }
+      static inline void setTimeFactor(float factor = 1.0) { Orxonox::getSingleton()->timefactor_ = factor; }
+      static inline float getTimeFactor() { return Orxonox::getSingleton()->timefactor_; }
+      static inline void exit() { Orxonox::getSingleton()->abortRequest(); }
    private:
       // don't mess with singletons
 …
       HUD*                  orxonoxHUD_;
       bool                  bAbort_;        //!< aborts the render loop if true
+      float                 timefactor_;    //!< A factor to change the gamespeed
       // this is used to identify the mode (server/client/...) we're in

code/trunk/src/orxonox/OrxonoxStableHeaders.h

r1032	r1052
97	97
98	98	#include "util/Math.h"
99		~~#include "util/Convert.h"~~
100	99	#include "util/Sleep.h"
101	100	#include "util/String2Number.h"

code/trunk/src/orxonox/core/BaseObject.cc

r1021	r1052
52	52	this->bVisible_ = true;
53	53	this->level_ = 0;
	54	this->namespace_ = 0;
54	55	}
55	56
…	…
78	79	@return The XML-element
79	80	*/
80		void BaseObject::XMLPort(Element& xmlelement, ~~bool loading~~)
	81	void BaseObject::XMLPort(Element& xmlelement, XMLPort::Mode mode)
81	82	{
82		XMLPortParam(BaseObject, "name", setName, getName, xmlelement, ~~loading~~);
	83	XMLPortParam(BaseObject, "name", setName, getName, xmlelement, mode);
83	84	}
84	85

code/trunk/src/orxonox/core/BaseObject.h

-                      r871
+                      r1052
             virtual ~BaseObject();
             virtual void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, bool loading);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             /** @brief Sets the name of the object. @param name The name */
 …
             const std::string& getLevelfile() const;
+            virtual inline void setNamespace(Namespace* ns) { this->namespace_ = ns; }
+            inline Namespace* getNamespace() const { return this->namespace_; }
             /** @brief Sets the indentation of the debug output in the Loader. @param indentation The indentation */
             inline void setLoaderIndentation(const std::string& indentation) { this->loaderIndentation_ = indentation; }
 …
             const Level* level_;                        //!< The level that loaded this object
             std::string loaderIndentation_;             //!< Indentation of the debug output in the Loader
+            Namespace* namespace_;
     };
+}

code/trunk/src/orxonox/core/CMakeLists.txt

-                      r1048
+                      r1052
   InputEventListener.cc
   MetaObjectList.cc
+  ConfigFileManager.cc
   ConfigValueContainer.cc
   Error.cc
   SignalHandler.cc
   DebugLevel.cc
+  CoreSettings.cc
   OutputHandler.cc
   Language.cc
 …
   Executor.cc
   XMLPort.cc
+  Namespace.cc
+  NamespaceNode.cc
+  CommandExecutor.cc
+  InputBuffer.cc
   Tickable.cc
   Script.cc

code/trunk/src/orxonox/core/ClassTreeMask.cc

-                      r1021
+                      r1052
+        {
             // No it's not: Search for classes inheriting from the given class and add the rules for them
             for (std::list<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
+            for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
                 if ((*it)->isA(this->root_->getClass()))
                     if (overwrite || (!this->nodeExists(*it))) // If we don't want to overwrite, only add nodes that don't already exist
 …
     void ClassTreeMask::addSingle(const Identifier* subclass, bool bInclude, bool clean)
+    {
         for (std::list<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
+        for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
             this->add(*it, this->isIncluded(*it), false, false);
 …
     /**
+        @brief Compares the mask with another mask and returns true if they represent the same logic.
+        @param other The other mask
+        @return True if both masks represent the same logic
+    */
+    bool ClassTreeMask::operator==(const ClassTreeMask& other) const
+    {
+        ClassTreeMask temp1 = other;
+        ClassTreeMask temp2 = (*this);
+        temp1.clean();
+        temp2.clean();
+        ClassTreeMaskIterator it1 = temp1.root_;
+        ClassTreeMaskIterator it2 = temp2.root_;
+        for ( ; it1 && it2; ++it1, ++it2)
+            if (it1->getClass() != it2->getClass())
+                return false;
+        return true;
+    }
+    /**
+        @brief Compares the mask with another mask and returns true if they represent different logics.
+        @param other The other mask
+        @return True if the masks represent different logics
+    */
+    bool ClassTreeMask::operator!=(const ClassTreeMask& other) const
+    {
+        return (!((*this) == other));
+    }
+    /**
         @brief Prefix operator + does nothing.
         @return A reference to the mask itself

code/trunk/src/orxonox/core/ClassTreeMask.h

-                      r871
+                      r1052
             ClassTreeMask& operator=(const ClassTreeMask& other);
+            bool operator==(const ClassTreeMask& other) const;
+            bool operator!=(const ClassTreeMask& other) const;
             ClassTreeMask& operator+();
             ClassTreeMask operator-() const;

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

-                      r871
+                      r1052
 #include "ConfigValueContainer.h"
+#include "util/Tokenizer.h"
+#include "Language.h"
+#include "Identifier.h"
+#include "util/SubString.h"
 #include "util/Convert.h"
+#include "Language.h"
+#define CONFIGFILEPATH "orxonox.ini"
+#define MAX_VECTOR_INDEX 255 // to avoid up to 4*10^9 vector entries in the config file after accidentally using a wrong argument
 namespace orxonox
 …
     /**
         @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(const std::string& classname, const std::string& varname, MultiTypeMath defvalue)
+    {
+    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const MultiTypeMath& defvalue)
+    {
+        this->type_ = type;
+        this->identifier_ = identifier;
+        this->sectionname_ = identifier->getName();
+        this->varname_ = varname;
+        this->value_ = defvalue;
         this->bAddedDescription_ = false;
+        this->classname_ = classname;
+        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->valueToString(&this->defvalueString_, defvalue);                      // Try to convert the default-value to a string
+        this->searchConfigFileLine();                                               // Search the entry in the config-file
+        std::string valueString = this->parseValueString(!(defvalue.isA(MT_string) || defvalue.isA(MT_constchar)));     // Parses the value string from the config-file-entry
+        if (!this->parseString(valueString, defvalue))                              // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+    /**
+        @brief Converts a value to a string.
+        @param output The string to write to
+        @param input The value to convert
+        @return True if the converson was successful
+    */
+    bool ConfigValueContainer::valueToString(std::string* output, MultiTypeMath& input)
+    {
+        if (input.getType() == MT_int)
+            return ConvertValue(output, input.getInt(), std::string("0"));
+        else if (input.getType() == MT_uint)
+            return ConvertValue(output, input.getUnsignedInt(), std::string("0"));
+        else if (input.getType() == MT_char)
+            return ConvertValue(output, (int)input.getChar(), std::string("0"));
+        else if (input.getType() == MT_uchar)
+            return ConvertValue(output, (unsigned int)input.getUnsignedChar(), std::string("0"));
+        else if (input.getType() == MT_short)
+            return ConvertValue(output, input.getShort(), std::string("0"));
+        else if (input.getType() == MT_ushort)
+            return ConvertValue(output, input.getUnsignedShort(), std::string("0"));
+        else if (input.getType() == MT_long)
+            return ConvertValue(output, input.getLong(), std::string("0"));
+        else if (input.getType() == MT_ulong)
+            return ConvertValue(output, input.getUnsignedLong(), std::string("0"));
+        else if (input.getType() == MT_float)
+            return ConvertValue(output, input.getFloat(), std::string("0.000000"));
+        else if (input.getType() == MT_double)
+            return ConvertValue(output, input.getDouble(), std::string("0.000000"));
+        else if (input.getType() == MT_longdouble)
+            return ConvertValue(output, input.getChar(), std::string("0.000000"));
+        else if (input.getType() == MT_bool)
+        {
+            if (input.getBool())
+                (*output) = "true";
+        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(), this->value_.isA(MT_string));
+        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], this->value_.isA(MT_string));
+                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;
+    }
+    /**
+        @brief Assigns a new value to the config-value of all objects and writes the change into the config-file.
+        @param input The new value
+        @return True if the new value was successfully assigned
+    */
+    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
+                (*output) = "false";
+            return true;
+        }
+        else if (input.getType() == MT_constchar)
+        {
+            (*output) = "\"" + input.getString() + "\"";
+            return true;
+        }
+        else if (input.getType() == MT_string)
+        {
+            (*output) = "\"" + input.getString() + "\"";
+            return true;
+        }
+        else if (input.getType() == MT_vector2)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getVector2().x << "," << input.getVector2().y << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0)";
+                return false;
+            }
+        }
+        else if (input.getType() == MT_vector3)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getVector3().x << "," << input.getVector3().y << "," << input.getVector3().z << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0,0)";
+                return false;
+            }
+        }
+        else if (input.getType() == MT_colourvalue)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getColourValue().r << "," << input.getColourValue().g << "," << input.getColourValue().b << "," << input.getColourValue().a << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0,0,0)";
+                return false;
+            }
+        }
+        else if (input.getType() == MT_quaternion)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getQuaternion().w << "," << input.getQuaternion().x << "," << input.getQuaternion().y << "," << input.getQuaternion().z << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0,0,0)";
+                return false;
+            }
+        }
+        else if (input.getType() == MT_radian)
+            return ConvertValue(output, input.getRadian(), std::string("0.000000"));
+        else if (input.getType() == MT_degree)
+            return ConvertValue(output, input.getDegree(), std::string("0.000000"));
+        return false;
+                return this->set(index, "");
+        }
+        bool success = this->tset(input);
+        ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, input, this->value_.isA(MT_string));
+        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, this->value_.isA(MT_string));
+            return success;
+        }
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        return false;
+    }
+    /**
+        @brief Assigns a new value to the config-value of all objects, but doesn't change the config-file (t stands for temporary).
+        @param input The new value
+        @return True if the new value was successfully assigned
+    */
+    bool ConfigValueContainer::tset(const std::string& input)
+    {
+        bool success = this->parse(input);
+        if (this->identifier_)
+            this->identifier_->updateConfigValues();
+        return success;
+    }
+    /**
+        @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()
+    {
+        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;
+        }
+    }
+    /**
+        @brief Retrieves the configured value from the currently loaded config-file.
+    */
+    void ConfigValueContainer::update()
+    {
+        if (!this->bIsVector_)
+            this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isA(MT_string)));
+        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->value_.isA(MT_string)));
+                this->valueVector_.push_back(this->value_);
+            }
+        }
+    }
 …
         @return True if the string was successfully parsed
     */
+    bool ConfigValueContainer::parseString(const std::string& input, MultiTypeMath& defvalue)
+    {
+        if (defvalue.getType() == MT_int)
+            return this->parseString(input, defvalue.getInt());
+        else if (defvalue.getType() == MT_uint)
+            return this->parseString(input, defvalue.getUnsignedInt());
+        else if (defvalue.getType() == MT_char)
+            return this->parseString(input, defvalue.getChar());
+        else if (defvalue.getType() == MT_uchar)
+            return this->parseString(input, defvalue.getUnsignedChar());
+        else if (defvalue.getType() == MT_short)
+            return this->parseString(input, defvalue.getShort());
+        else if (defvalue.getType() == MT_ushort)
+            return this->parseString(input, defvalue.getUnsignedShort());
+        else if (defvalue.getType() == MT_long)
+            return this->parseString(input, defvalue.getLong());
+        else if (defvalue.getType() == MT_ulong)
+            return this->parseString(input, defvalue.getUnsignedLong());
+        else if (defvalue.getType() == MT_float)
+            return this->parseString(input, defvalue.getFloat());
+        else if (defvalue.getType() == MT_double)
+            return this->parseString(input, defvalue.getDouble());
+        else if (defvalue.getType() == MT_longdouble)
+            return this->parseString(input, defvalue.getLongDouble());
+        else if (defvalue.getType() == MT_bool)
+            return this->parseString(input, defvalue.getBool());
+        else if (defvalue.getType() == MT_constchar)
+            return this->parseString(input, defvalue.getString());
+        else if (defvalue.getType() == MT_string)
+            return this->parseString(input, defvalue.getString());
+        else if (defvalue.getType() == MT_vector2)
+            return this->parseString(input, defvalue.getVector2());
+        else if (defvalue.getType() == MT_vector3)
+            return this->parseString(input, defvalue.getVector3());
+        else if (defvalue.getType() == MT_colourvalue)
+            return this->parseString(input, defvalue.getColourValue());
+        else if (defvalue.getType() == MT_quaternion)
+            return this->parseString(input, defvalue.getQuaternion());
+        else if (defvalue.getType() == MT_radian)
+            return this->parseString(input, defvalue.getRadian());
+        else if (defvalue.getType() == MT_degree)
+            return this->parseString(input, defvalue.getDegree());
+        return false;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type int and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, int defvalue)
+    {
+        int temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type unsigned int and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned int defvalue)
+    {
+        unsigned int temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type char and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, char defvalue)
+    {
+        // I used value_int_ instead of value_char_ to avoid number <-> char confusion in the config-file
+        int temp;
+        bool success = ConvertValue(&temp, input, (int)defvalue);
+        this->value_.setValue((char)temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type unsigned char and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned char defvalue)
+    {
+        // I used value_uint_ instead of value_uchar_ to avoid number <-> char confusion in the config-file
+        unsigned int temp;
+        bool success = ConvertValue(&temp, input, (unsigned int)defvalue);
+        this->value_.setValue((unsigned char)temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type short and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, short defvalue)
+    {
+        short temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type unsigned short and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned short defvalue)
+    {
+        unsigned short temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type long and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, long defvalue)
+    {
+        long temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type unsigned long and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned long defvalue)
+    {
+        unsigned long temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type float and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, float defvalue)
+    {
+        float temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, double defvalue)
+    {
+        double temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type long double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, long double defvalue)
+    {
+        long double temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        this->value_.setValue(temp);
+        return success;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type bool and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, bool defvalue)
+    {
+        // Try to parse the value-string - is it a word?
+        if (input.find("true") < input.size()
+         || input.find("True") < input.size()
+         || input.find("yes") < input.size()
+         || input.find("Yes") < input.size())
+            this->value_.setValue(true);
+        else if (input.find("false") < input.size()
+              || input.find("False") < input.size()
+              || input.find("no") < input.size()
+              || input.find("No") < input.size())
+            this->value_.setValue(false);
+        else
+        {
+            // Its not a known word - is it a number?
+            bool temp;
+            bool success = ConvertValue(&temp, input, defvalue);
+            this->value_.setValue(temp);
+            return success;
+        }
+        return true;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type std::string and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const std::string& defvalue)
+    {
+        // Strip the quotes
+        unsigned int pos1 = input.find("\"") + 1;
+        unsigned int pos2 = input.find("\"", pos1);
+        // Check if the entry was correctly quoted
+        if (pos1 < input.length() && pos2 < input.length() && !(input.find("\"", pos2 + 1) < input.length()))
+        {
+            // It was - get the string between the quotes
+            this->value_.setValue(input.substr(pos1, pos2 - pos1));
+            return true;
+        }
+        // It wasn't - use the default-value and restore the entry in the config-file.
+        this->value_.setValue(defvalue);
+        return false;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type const char* and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const char* defvalue)
+    {
+        // Strip the quotes
+        unsigned int pos1 = input.find("\"") + 1;
+        unsigned int pos2 = input.find("\"", pos1);
+        // Check if the entry was correctly quoted
+        if (pos1 < input.length() && pos2 < input.length() && !(input.find("\"", pos2 + 1) < input.length()))
+        {
+            // It was - get the string between the quotes
+            this->value_.setValue(input.substr(pos1, pos2 - pos1));
+            return true;
+        }
+        // It wasn't - use the default-value and restore the entry in the config-file.
+        this->value_.setValue(defvalue);
+        return false;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type _Vector2 and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Vector2& defvalue)
+    {
+        // Strip the value-string
+        unsigned int pos1 = input.find("(") + 1;
+        unsigned int pos2 = input.find(")", pos1);
+        // Try to convert the stripped value-string to Vector2
+        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
+        {
+            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            if (!ConvertValue(&this->value_.getVector2().x, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getVector2().y, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            return true;
+        }
+        this->value_.setValue(defvalue);
+        return false;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type Vector3 and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Vector3& defvalue)
+    {
+        // Strip the value-string
+        unsigned int pos1 = input.find("(") + 1;
+        unsigned int pos2 = input.find(")", pos1);
+        // Try to convert the stripped value-string to Vector3
+        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
+        {
+            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            if (!ConvertValue(&this->value_.getVector3().x, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getVector3().y, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getVector3().z, tokens[2]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            return true;
+        }
+        this->value_.setValue(defvalue);
+        return false;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type ColourValue and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const ColourValue& defvalue)
+    {
+        // Strip the value-string
+        unsigned int pos1 = input.find("(") + 1;
+        unsigned int pos2 = input.find(")", pos1);
+        // Try to convert the stripped value-string to Vector3
+        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
+        {
+            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            if (!ConvertValue(&this->value_.getColourValue().r, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getColourValue().g, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getColourValue().b, tokens[2]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getColourValue().a, tokens[3]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            return true;
+        }
+        this->value_.setValue(defvalue);
+        return false;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type Quaternion and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Quaternion& defvalue)
+    {
+        // Strip the value-string
+        unsigned int pos1 = input.find("(") + 1;
+        unsigned int pos2 = input.find(")", pos1);
+        // Try to convert the stripped value-string to Vector3
+        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
+        {
+            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            if (!ConvertValue(&this->value_.getQuaternion().w, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getQuaternion().x, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getQuaternion().y, tokens[2]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getQuaternion().z, tokens[3]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            return true;
+        }
+        this->value_.setValue(defvalue);
+        return false;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type long double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Radian& defvalue)
+    {
+        return ConvertValue(&this->value_.getRadian(), input, defvalue);
+    }
+    /**
+        @brief Parses a given std::string into a value of the type long double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Degree& defvalue)
+    {
+        return ConvertValue(&this->value_.getDegree(), input, defvalue);
+    }
+    /**
+        @brief Sets the corresponding entry in the config-file back to the default value.
+    */
+    void ConfigValueContainer::resetConfigFileEntry()
+    {
+        (*this->configFileLine_) = this->varname_ + "=" + this->defvalueString_;
+        ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);
+    }
+    /**
+        @brief Sets the value of the variable back to the default value and resets the config-file entry.
+    */
+    void ConfigValueContainer::resetConfigValue()
+    {
+        this->parseString(this->defvalueString_, this->value_);
+        this->resetConfigFileEntry();
+    }
+    /**
+        @brief Searches the corresponding entry in the config-file and creates it, if there is no entry.
+    */
+    void ConfigValueContainer::searchConfigFileLine()
+    {
+        // Read the file if needed
+        if (!ConfigValueContainer::finishedReadingConfigFile())
+            ConfigValueContainer::readConfigFile(CONFIGFILEPATH);
+        // The string of the section we're searching
+        std::string section = "";
+        section.append("[");
+        section.append(this->classname_);
+        section.append("]");
+        // Iterate through all config-file-lines
+        bool success = false;
+        std::list<std::string>::iterator it1;
+        for(it1 = ConfigValueContainer::getConfigFileLines().begin(); it1 != ConfigValueContainer::getConfigFileLines().end(); ++it1)
+        {
+            // Don't try to parse comments
+            if (this->isComment(*it1))
+                continue;
+            if ((*it1).find(section) < (*it1).length())
+            {
+                // We found the right section
+                bool bLineIsEmpty = false;
+                std::list<std::string>::iterator positionToPutNewLineAt;
+                // Iterate through all lines in the section
+                std::list<std::string>::iterator it2;
+                for(it2 = ++it1; it2 != ConfigValueContainer::getConfigFileLines().end(); ++it2)
+                {
+                    // Don't try to parse comments
+                    if (this->isComment(*it2))
+                        continue;
+                    // This if-else block is used to write a new line right after the last line of the
+                    // section but in front of the following empty lines before the next section.
+                    // (So this helps to keep a nice formatting with empty-lines between sections in the config-file)
+                    if (this->isEmpty(*it2))
+                    {
+                        if (!bLineIsEmpty)
+                        {
+                            bLineIsEmpty = true;
+                            positionToPutNewLineAt = it2;
+                        }
+                    }
+                    else
+                    {
+                        if (!bLineIsEmpty)
+                            positionToPutNewLineAt = it2;
+                        bLineIsEmpty = false;
+                    }
+                    // Look out for the beginning of the next section
+                    unsigned int open = (*it2).find("[");
+                    unsigned int close = (*it2).find("]");
+                    if ((open < (*it2).length()) && (close < (*it2).length()) && (open < close))
+                    {
+                        // The next section startet, so our line isn't yet in the file - now we add it and safe the file
+                        this->configFileLine_ = this->getConfigFileLines().insert(positionToPutNewLineAt, this->varname_ + "=" + this->defvalueString_);
+                        ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);
+                        success = true;
+                        break;
+                    }
+                    // Look out for the variable-name
+                    if ((*it2).find(this->varname_) < (*it2).length())
+                    {
+                        // We found the right line - safe it and return
+                        this->configFileLine_ = it2;
+                        success = true;
+                        break;
+                    }
+                }
+                // Check if we succeeded
+    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)
+            {
                 if (!success)
+                {
+                    // Looks like we found the right section, but the file ended without containing our variable - so we add it and safe the file
+                    this->configFileLine_ = this->getConfigFileLines().insert(positionToPutNewLineAt, this->varname_ + "=" + this->defvalueString_);
+                    ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);
+                    success = true;
+                    COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is a vector." << std::endl;
+                }
+                break;
+            }
+        }
+        // Check if we succeeded
+        if (!success)
+        {
+            // We obviously didn't found the right section, so we'll create it
+            this->getConfigFileLines().push_back("[" + this->classname_ + "]");                   // Create the section
+            this->getConfigFileLines().push_back(this->varname_ + "=" + this->defvalueString_);   // Create the line
+            this->configFileLine_ = --this->getConfigFileLines().end();                           // Set the pointer to the last element
+            success = true;
+            this->getConfigFileLines().push_back("");                                             // Add an empty line - this is needed for the algorithm in the searchConfigFileLine-function
+            ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);                              // Save the changed config-file
+        }
+    }
+    /**
+        @brief Determines if a line in the config-file is a comment.
+        @param line The line to check
+        @return True = it's a comment
+    */
+    bool ConfigValueContainer::isComment(const std::string& line)
+    {
+        // Strip the line, whitespaces are disturbing
+        std::string teststring = getStrippedLine(line);
+        // There are four possible comment-symbols:
+        //  1) #comment in script-language style
+        //  2) %comment in matlab style
+        //  3) ;comment in unreal tournament config-file style
+        //  4) //comment in code style
+        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[0] == '/'))
+                else
+                {
+                    COUT(1) << "Error: Invalid vector-index." << std::endl;
+                }
+                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))
+        {
+            this->value_ = temp;
             return true;
+        return false;
+    }
+    /**
+        @brief Determines if a line in the config-file is empty (contains only whitespaces).
+        @param line The line to check
+        @return True = it's empty
+    */
+    bool ConfigValueContainer::isEmpty(const std::string& line)
+    {
+        return getStrippedLine(line) == "";
+    }
+    /**
+        @brief Removes all whitespaces from a line.
+        @param line The line to strip
+        @return The stripped line
+    */
+    std::string ConfigValueContainer::getStrippedLine(const std::string& line)
+    {
+        std::string output = line;
+        unsigned int pos;
+        while ((pos = output.find(" ")) < output.length())
+            output.erase(pos, 1);
+        while ((pos = output.find("\t")) < output.length())
+            output.erase(pos, 1);
+        return output;
+    }
+    /**
+        @brief Returns the part in the corresponding config-file-entry of the container that defines the value.
+        @param bStripped True = strip the value-string
+        @return The value-string
+    */
+    std::string ConfigValueContainer::parseValueString(bool bStripped)
+    {
+        std::string output;
+        if (bStripped)
+            output = this->getStrippedLine(*this->configFileLine_);
+        else
+            output = *this->configFileLine_;
+        return output.substr(output.find("=") + 1);
+    }
+    /**
+        @brief Rreturns a list, containing all entrys in the config-file.
+        @return The list
+    */
+    std::list<std::string>& ConfigValueContainer::getConfigFileLines()
+    {
+        // This is done to avoid problems while executing this code before main()
+        static std::list<std::string> configFileLinesStaticReference = std::list<std::string>();
+        return configFileLinesStaticReference;
+    }
+    /**
+        @brief Returns true if the ConfigFile is read and stored into the ConfigFile-lines-list.
+        @param finished This is used to change the state
+        @return True if the ConfigFile is read and stored into the ConfigFile-lines-list
+    */
+    bool ConfigValueContainer::finishedReadingConfigFile(bool finished)
+    {
+        // This is done to avoid problems while executing this code before main()
+        static bool finishedReadingConfigFileStaticVariable = false;
+        if (finished)
+            finishedReadingConfigFileStaticVariable = true;
+        return finishedReadingConfigFileStaticVariable;
+    }
+    /**
+        @brief Reads the config-file and stores the lines in a list.
+        @param filename The name of the config-file
+    */
+    void ConfigValueContainer::readConfigFile(const std::string& filename)
+    {
+        // This creates the file if it's not existing
+        std::ofstream createFile;
+        createFile.open(filename.c_str(), std::fstream::app);
+        createFile.close();
+        // Open the file
+        std::ifstream file;
+        file.open(filename.c_str(), std::fstream::in);
+        if (!file.is_open())
+        {
+            COUT(1) << "An error occurred in ConfigValueContainer.cc:" << std::endl;
+            COUT(1) << "Error: Couldn't open config-file " << filename << " to read the config values!" << std::endl;
+            return;
+        }
+        char line[1024];
+        // Iterate through the file and add the lines into the list
+        while (file.good() && !file.eof())
+        {
+            file.getline(line, 1024);
+            ConfigValueContainer::getConfigFileLines().push_back(line);
+//            std::cout << "### ->" << line << "<- : empty: " << isEmpty(line) << " comment: " << isComment(line) << std::endl;
+        }
+        // The last line is useless
+        ConfigValueContainer::getConfigFileLines().pop_back();
+        // Add an empty line to the end of the file if needed
+        // this is needed for the algorithm in the searchConfigFileLine-function
+        if ((ConfigValueContainer::getConfigFileLines().size() > 0) && !isEmpty(*ConfigValueContainer::getConfigFileLines().rbegin()))
+        {
+//            std::cout << "### newline added" << std::endl;
+            ConfigValueContainer::getConfigFileLines().push_back("");
+        }
+        file.close();
+        ConfigValueContainer::finishedReadingConfigFile(true);
+    }
+    /**
+        @brief Writes the content of the list, containing all lines of the config-file, into the config-file.
+        @param filename The name of the config-file
+    */
+    void ConfigValueContainer::writeConfigFile(const std::string& filename)
+    {
+        // Make sure we stored the config-file in the list
+        if (!ConfigValueContainer::finishedReadingConfigFile())
+            ConfigValueContainer::readConfigFile(filename);
+        // Open the file
+        std::ofstream file;
+        file.open(filename.c_str(), std::fstream::out);
+        if (!file.is_open())
+        {
+            COUT(1) << "An error occurred in ConfigValueContainer.cc:" << std::endl;
+            COUT(1) << "Error: Couldn't open config-file " << filename << " to write the config values!" << std::endl;
+            return;
+        }
+        // Iterate through the list an write the lines into the file
+        std::list<std::string>::iterator it;
+        for (it = ConfigValueContainer::getConfigFileLines().begin(); it != ConfigValueContainer::getConfigFileLines().end(); ++it)
+        {
+            file << (*it) << std::endl;
+        }
+        file.close();
+        }
+        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], this->value_.isA(MT_string));
+                }
+            }
+            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;
+    }
+    /**
+        @brief Parses a given std::string into a value of the type of the associated variable and assigns it.
+        @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(const std::string& input, const MultiTypeMath& defvalue)
+    {
+        if (this->parse(input))
+            return true;
+        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;
+        }
+        COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
+        return false;
+    }
 …
         if (!this->bAddedDescription_)
+        {
             this->description_ = std::string("ConfigValueDescription::" + this->classname_ + "::" + this->varname_);
+            this->description_ = std::string("ConfigValueDescription::" + this->identifier_->getName() + "::" + this->varname_);
             AddLanguageEntry(this->description_, description);
             this->bAddedDescription_ = true;

code/trunk/src/orxonox/core/ConfigValueContainer.h

-                      r871
+                      r1052
 #define _ConfigValueContainer_H__
-#include <list>
 #include <string>
+#include <vector>
 #include "CorePrereqs.h"
 …
 #include "util/Math.h"
 #include "util/MultiTypeMath.h"
+#include "ConfigFileManager.h"
 namespace orxonox
 …
+    {
         public:
+            ConfigValueContainer(const std::string& classname, 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 */
+/*            template <typename T>
+            inline ConfigValueContainer& getValue(T& value)                           { this->value_.getValue(value); return *this; }
+*/
+            inline ConfigValueContainer& getValue(int* value)            { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned int* value)   { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(char* value)           { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned char* value)  { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(short* value)          { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned short* value) { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(long* value)           { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned long* value)  { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(float* value)          { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(double* value)         { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(long double* value)    { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(bool* value)           { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(std::string* value)    { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(const char** value)    { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Vector2* value)        { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Vector3* value)        { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(ColourValue* value)    { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Quaternion* value)     { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Radian* value)         { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Degree* value)         { this->value_.getValue(value); return *this; }
+            template <typename T>
+            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() 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 parseString(const std::string& input, MultiTypeMath& defvalue);
+            bool valueToString(std::string* output, MultiTypeMath& input);
+            void resetConfigFileEntry();
+            void resetConfigValue();
+            bool add(const std::string& input);
+            bool remove(unsigned int index);
+            bool set(const std::string& input);
+            bool tset(const std::string& input);
+            bool reset();
+            void update();
+            static std::string getStrippedLine(const std::string& line);
+            static bool isEmpty(const std::string& line);
+            static bool isComment(const std::string& line);
+            /** @brief Converts the config-value to a string. @return The string */
+            inline std::string toString() const
+                { return this->value_.toString(); }
+            /** @brief Returns the typename of the assigned config-value. @return The typename */
+            inline std::string getTypename() const
+                { return this->value_.getTypename(); }
         private:
+            bool parseString(const std::string& input, int defvalue);
+            bool parseString(const std::string& input, unsigned int defvalue);
+            bool parseString(const std::string& input, char defvalue);
+            bool parseString(const std::string& input, unsigned char defvalue);
+            bool parseString(const std::string& input, short defvalue);
+            bool parseString(const std::string& input, unsigned short defvalue);
+            bool parseString(const std::string& input, long defvalue);
+            bool parseString(const std::string& input, unsigned long defvalue);
+            bool parseString(const std::string& input, float defvalue);
+            bool parseString(const std::string& input, double defvalue);
+            bool parseString(const std::string& input, long double defvalue);
+            bool parseString(const std::string& input, bool defvalue);
+            bool parseString(const std::string& input, const std::string& defvalue);
+            bool parseString(const std::string& input, const char* defvalue);
+            bool parseString(const std::string& input, const Vector2& defvalue);
+            bool parseString(const std::string& input, const Vector3& defvalue);
+            bool parseString(const std::string& input, const ColourValue& defvalue);
+            bool parseString(const std::string& input, const Quaternion& defvalue);
+            bool parseString(const std::string& input, const Radian& defvalue);
+            bool parseString(const std::string& input, const Degree& defvalue);
+            bool parse(const std::string& input);
+            bool parse(const std::string& input, const MultiTypeMath& defvalue);
             static std::list<std::string>& getConfigFileLines();
             static bool finishedReadingConfigFile(bool finished = false);
             void searchConfigFileLine();
             std::string parseValueString(bool bStripped = true);
+            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);
+            static void readConfigFile(const std::string& filename);
+            static void writeConfigFile(const std::string& filename);
+            bool                       bIsVector_;                  //!< True if the container contains a std::vector
+            std::string         classname_;                     //!< 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
+            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
+            MultiTypeMath       value_;                         //!< The value
+            MultiTypeMath              value_;                      //!< The value
+            std::vector<MultiTypeMath> valueVector_;                //!< A vector, containg the 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
+            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/trunk/src/orxonox/core/CoreIncludes.h

-                      r871
+                      r1052
 /**
     @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
 …
 #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 "Debug.h"
-// All needed macros
 /**
     @brief Intern macro, containing the common parts of RegisterObject and RegisterRootObject.
 …
     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(this->getIdentifier()->getName(), #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->resetConfigValue(); \
-        container##varname##reset->getValue(&varname); \
-    } \
-    else \
-        COUT(2) << "Warning: Couldn't reset variable " << #varname << ", corresponding container doesn't exist." << std::endl
 #endif /* _CoreIncludes_H__ */

code/trunk/src/orxonox/core/CorePrereqs.h

-                      r1024
+                      r1052
 namespace orxonox
+{
+#ifndef _XMLPort_Mode__
+#define _XMLPort_Mode__
+  namespace XMLPort
+  {
+    enum Mode
+    {
+      LoadObject,
+      SaveObject
+    };
+  }
+#endif
   typedef std::string LanguageEntryLabel;
 …
   class ClassTreeMaskIterator;
   class ClassTreeMaskNode;
+  class CommandEvaluation;
+  class CommandExecutor;
+  class ConfigFile;
+  class ConfigFileEntry;
+  class ConfigFileEntryComment;
+  class ConfigFileEntryValue;
+  class ConfigFileManager;
+  class ConfigFileSection;
   class ConfigValueContainer;
   class DebugLevel;
+  class CoreSettings;
   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;
+  class InputBuffer;
+  class InputBufferListener;
   class InputHandlerGame;
   class InputHandlerGUI;
 …
   template <class T>
   class MetaObjectListElement;
+  class Namespace;
+  class NamespaceNode;
   template <class T>
   class ObjectList;
 …
   class OrxonoxClass;
   class OutputHandler;
+  class Shell;
   template <class T>
   class SubclassIdentifier;

code/trunk/src/orxonox/core/Executor.cc

-                      r871
+                      r1052
 #include "Executor.h"
 #include "Language.h"
 #include "util/String.h"
+#include "util/Math.h"
 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;
         this->bAddedDescriptionParam_[0] = false;
         this->bAddedDescriptionParam_[1] = false;
 …
         this->bAddedDescriptionParam_[3] = false;
         this->bAddedDescriptionParam_[4] = false;
+        this->bAddedDefaultValue_[0] = false;
+        this->bAddedDefaultValue_[1] = false;
+        this->bAddedDefaultValue_[2] = false;
+        this->bAddedDefaultValue_[3] = false;
+        this->bAddedDefaultValue_[4] = false;
+    }
     Executor::~Executor()
+    {
+    }
+    void Executor::setName(const std::string name)
+    {
+        this->name_ = name;
+    }
+    const std::string& Executor::getName() const
+    {
+        return this->name_;
+    }
+    void Executor::description(const std::string& description)
+        delete this->functor_;
+    }
+    bool Executor::parse(const std::string& params, const std::string& delimiter) const
+    {
+        EXECUTOR_PARSE(normal);
+    }
+    bool Executor::evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter) const
+    {
+        unsigned int paramCount = this->functor_->getParamCount();
+        if (paramCount == 1)
+        {
+            // only one param: check if there are params given, otherwise try to use default values
+            std::string temp = getStripped(params);
+            if ((temp != "") && (temp.size() != 0))
+            {
+                param[0] = params;
+                this->functor_->evaluateParam(0, param[0]);
+                return true;
+            }
+            else if (this->bAddedDefaultValue_[0])
+            {
+                param[0] = this->defaultValue_[0];
+                this->functor_->evaluateParam(0, param[0]);
+                return true;
+            }
+            return false;
+        }
+        else
+        {
+            // more than one param
+            SubString tokens(params, delimiter, SubString::WhiteSpaces, false, '\\', true, '"', true, '(', ')', true, '\0');
+            // if there are not enough params given, check if there are default values
+            for (unsigned int i = tokens.size(); i < this->functor_->getParamCount(); i++)
+                if (!this->bAddedDefaultValue_[i])
+                    return false;
+            // assign all given arguments to the multitypes
+            for (unsigned int i = 0; i < min(tokens.size(), (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
+                param[i] = tokens[i];
+            // fill the remaining multitypes with default values
+            for (unsigned int i = tokens.size(); i < min(paramCount, (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
+                param[i] = this->defaultValue_[i];
+            // evaluate the param types through the functor
+            for (unsigned int i = 0; i < min(paramCount, (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
+                this->functor_->evaluateParam(i, param[i]);
+            return true;
+        }
+    }
+    Executor& Executor::setDescription(const std::string& description)
+    {
         if (!this->bAddedDescription_)
 …
             this->bAddedDescription_ = true;
+        }
+        return (*this);
+    }
 …
+    }
     void Executor::descriptionParam(int param, const std::string& description)
+    {
         if (param > 0 && param <= 5)
+    Executor& Executor::setDescriptionParam(int param, const std::string& description)
+    {
+        if (param >= 0 && param < MAX_FUNCTOR_ARGUMENTS)
+        {
             if (!this->bAddedDescriptionParam_[param])
 …
                 std::string paramnumber;
                 if (!Convert::ToString(&paramnumber, param))
                     return;
+                    return (*this);
                 this->descriptionParam_[param] = std::string("ExecutorDescription::" + this->name_ + "::param" + paramnumber);
 …
+            }
+        }
+        return (*this);
+    }
     const std::string& Executor::getDescriptionParam(int param) const
+    {
+        if (param > 0 && param <= 5)
+        {
+        if (param >= 0 && param < MAX_FUNCTOR_ARGUMENTS)
             return GetLocalisation(this->descriptionParam_[param]);
+        }
         return this->descriptionParam_[0];
+    }
     void Executor::descriptionReturnvalue(const std::string& description)
+    Executor& Executor::setDescriptionReturnvalue(const std::string& description)
+    {
         if (!this->bAddedDescriptionReturnvalue_)
 …
             this->bAddedDescriptionReturnvalue_ = true;
+        }
+        return (*this);
+    }
 …
         return GetLocalisation(this->descriptionReturnvalue_);
+    }
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        return (*this);
+    }
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+        return (*this);
+    }
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+        this->defaultValue_[2] = param3;
+        this->bAddedDefaultValue_[2] = true;
+        return (*this);
+    }
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+        this->defaultValue_[2] = param3;
+        this->bAddedDefaultValue_[2] = true;
+        this->defaultValue_[3] = param4;
+        this->bAddedDefaultValue_[3] = true;
+        return (*this);
+    }
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+        this->defaultValue_[2] = param3;
+        this->bAddedDefaultValue_[2] = true;
+        this->defaultValue_[3] = param4;
+        this->bAddedDefaultValue_[3] = true;
+        this->defaultValue_[4] = param5;
+        this->bAddedDefaultValue_[4] = true;
+        return (*this);
+    }
+    Executor& Executor::setDefaultValue(unsigned int index, const MultiTypeMath& param)
+    {
+        if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
+        {
+            this->defaultValue_[index] = param;
+            this->bAddedDefaultValue_[index] = true;
+        }
+        return (*this);
+    }
+    bool Executor::allDefaultValuesSet() const
+    {
+        for (unsigned int i = 0; i < this->functor_->getParamCount(); i++)
+            if (!this->bAddedDefaultValue_[i])
+                return false;
+        return true;
+    }
+}

code/trunk/src/orxonox/core/Executor.h

-                      r871
+                      r1052
 #include "CorePrereqs.h"
 #include "Functor.h"
+#include "Debug.h"
+#include "util/SubString.h"
+#include "util/String.h"
+#define EXECUTOR_PARSE_FUNCTORCALL(mode) EXECUTOR_PARSE_FUNCTORCALL##mode
+#define EXECUTOR_PARSE_FUNCTORCALLnormal (*this->functor_)
+#define EXECUTOR_PARSE_FUNCTORCALLobject (*((FunctorMember<T>*)this->functor_))
+#define EXECUTOR_PARSE_OBJECT(mode, comma) EXECUTOR_PARSE_OBJECT##mode##comma
+#define EXECUTOR_PARSE_OBJECTnormal0
+#define EXECUTOR_PARSE_OBJECTnormal1
+#define EXECUTOR_PARSE_OBJECTobject0 object
+#define EXECUTOR_PARSE_OBJECTobject1 object,
+#define EXECUTOR_PARSE(mode) \
+    unsigned int paramCount = this->functor_->getParamCount(); \
+    \
+    if (paramCount == 0) \
+    { \
+        COUT(5) << "Calling Executor " << this->name_ << " through parser without parameters." << std::endl; \
+        EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 0)); \
+    } \
+    else if (paramCount == 1) \
+    { \
+        std::string temp = getStripped(params); \
+        if ((temp != "") && (temp.size() != 0)) \
+        { \
+            COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using whole string: " << params << std::endl; \
+            EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) MultiTypeMath(params)); \
+        } \
+        else if (this->bAddedDefaultValue_[0]) \
+        { \
+            COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using default value: " << this->defaultValue_[0] << std::endl; \
+            EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) this->defaultValue_[0]); \
+        } \
+        else \
+        { \
+            COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough parameters or default values given (input: " << temp << ")." << std::endl; \
+            return false; \
+        } \
+    } \
+    else \
+    { \
+        SubString tokens(params, delimiter, SubString::WhiteSpaces, false, '\\', true, '"', true, '(', ')', true, '\0'); \
+        \
+        for (unsigned int i = tokens.size(); i < this->functor_->getParamCount(); i++) \
+        { \
+            if (!this->bAddedDefaultValue_[i]) \
+            { \
+                COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough parameters or default values given (input:" << params << ")." << std::endl; \
+                return false; \
+            } \
+        } \
+        \
+        MultiTypeMath param[MAX_FUNCTOR_ARGUMENTS]; \
+        COUT(5) << "Calling Executor " << this->name_ << " through parser with " << paramCount << " parameters, using " << tokens.size() << " tokens ("; \
+        for (unsigned int i = 0; i < tokens.size() && i < MAX_FUNCTOR_ARGUMENTS; i++) \
+        { \
+            param[i] = tokens[i]; \
+            if (i != 0) \
+            { \
+                COUT(5) << ", "; \
+            } \
+            COUT(5) << tokens[i]; \
+        } \
+        COUT(5) << ") and " << (paramCount - tokens.size()) << " default values ("; \
+        for (unsigned int i = tokens.size(); i < paramCount; i++) \
+        { \
+            param[i] = this->defaultValue_[i]; \
+            if (i != 0) \
+            { \
+                COUT(5) << ", "; \
+            } \
+            COUT(5) << this->defaultValue_[i]; \
+        } \
+        COUT(5) << ")." << std::endl; \
+        \
+        if ((tokens.size() > paramCount) && (this->functor_->getTypenameParam(paramCount - 1) == "string")) \
+            param[paramCount - 1] = tokens.subSet(paramCount - 1).join(); \
+        \
+        switch(paramCount) \
+        { \
+            case 2: \
+                EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) param[0], param[1]); \
+                break; \
+            case 3: \
+                EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) param[0], param[1], param[2]); \
+                break; \
+            case 4: \
+                EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) param[0], param[1], param[2], param[3]); \
+                break; \
+            case 5: \
+                EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) param[0], param[1], param[2], param[3], param[4]); \
+                break; \
+        } \
+    } \
+    \
+    return true
+namespace AccessLevel
+{
+    enum Level
+    {
+        None,
+        User,
+        Admin,
+        Offline,
+        Debug,
+        Disabled
+    };
+}
 namespace orxonox
 …
+    {
         public:
             Executor(Functor* functor, const std::string& name = "");
+            Executor(Functor* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None);
             virtual ~Executor();
+            inline 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)
+            inline void operator()() const
+                { (*this->functor_)(this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const MultiTypeMath& param1) const
+                { (*this->functor_)(param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2) const
+                { (*this->functor_)(param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+                { (*this->functor_)(param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+                { (*this->functor_)(param1, param2, param3, param4, this->defaultValue_[4]); }
+            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
                 { (*this->functor_)(param1, param2, param3, param4, param5); }
+            void setName(const std::string name);
+            const std::string& getName() const;
+            void description(const std::string& description);
+            bool parse(const std::string& params, const std::string& delimiter = " ") const;
+            bool evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter = " ") const;
+            Executor& setDescription(const std::string& description);
             const std::string& getDescription() const;
             void descriptionParam(int param, const std::string& description);
+            Executor& setDescriptionParam(int param, const std::string& description);
             const std::string& getDescriptionParam(int param) const;
             void descriptionReturnvalue(const std::string& description);
+            Executor& setDescriptionReturnvalue(const std::string& description);
             const std::string& getDescriptionReturnvalue(int param) const;
             inline int getParamCount() const
+            inline unsigned int getParamCount() const
                 { return this->functor_->getParamCount(); }
             inline bool hasReturnvalue() const
 …
             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_; }
+            Executor& setDefaultValues(const MultiTypeMath& param1);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5);
+            Executor& setDefaultValue(unsigned int index, const MultiTypeMath& param);
+            inline MultiTypeMath getDefaultValue(unsigned int index) const
+            {
+                if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
+                    return this->defaultValue_[index];
+                return MT_null;
+            }
+            bool allDefaultValuesSet() const;
+            inline bool defaultValueSet(unsigned int index) const
+            {
+                if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
+                    return this->bAddedDefaultValue_[index];
+                return false;
+            }
         protected:
             Functor* functor_;
+            std::string name_;
+            MultiTypeMath defaultValue_[MAX_FUNCTOR_ARGUMENTS];
+            bool bAddedDefaultValue_[MAX_FUNCTOR_ARGUMENTS];
         private:
-            std::string name_;
             LanguageEntryLabel description_;
             LanguageEntryLabel descriptionReturnvalue_;
             LanguageEntryLabel descriptionParam_[5];
+            LanguageEntryLabel descriptionParam_[MAX_FUNCTOR_ARGUMENTS];
             bool bAddedDescription_;
             bool bAddedDescriptionReturnvalue_;
+            bool bAddedDescriptionParam_[5];
+            bool bAddedDescriptionParam_[MAX_FUNCTOR_ARGUMENTS];
+            AccessLevel::Level accessLevel_;
     };
 …
+    {
         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() {}
-            inline 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)
-                { (*this->functor_)(param1, param2, param3, param4, param5); }
     };
 …
+    {
         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() {}
+            inline 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)
+                { (*this->functor_)(object, param1, param2, param3, param4, param5); }
+            inline 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)
+                { (*this->functor_)(object, param1, param2, param3, param4, param5); }
+            inline 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)
+                { (*this->functor_)(param1, param2, param3, param4, param5); }
+            inline void setObject(T* object)
+                { this->functor_->setObject(object); }
+            inline void setObject(const T* object)
+                { this->functor_->setObject(object); }
+            inline void operator()(T* object) const
+                { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(T* object, const MultiTypeMath& param1) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
+            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }
+            inline void operator()(const T* object) const
+                { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const T* object, const MultiTypeMath& param1) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
+            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
+            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+                { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }
+            inline void setObject(T* object) const
+                { ((FunctorMember<T>*)this->functor_)->setObject(object); }
+            inline void setObject(const T* object) const
+                { ((FunctorMember<T>*)this->functor_)->setObject(object); }
+            bool parse(T* object, const std::string& params, const std::string& delimiter = " ") const
+            {
+                EXECUTOR_PARSE(object);
+            }
+            bool parse(const T* object, const std::string& params, const std::string& delimiter = " ") const
+            {
+                EXECUTOR_PARSE(object);
+            }
     };
+    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 = "", AccessLevel::Level level = AccessLevel::None)
+    {
+        return new ExecutorMember<T>(functor, name, level);
+    }
+    inline ExecutorStatic* createExecutor(FunctorStatic* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None)
+    {
+        return new ExecutorStatic(functor, name, level);
+    }
+}

code/trunk/src/orxonox/core/Functor.h

-                      r871
+                      r1052
 #include "CorePrereqs.h"
+enum FunctionType
+#define MAX_FUNCTOR_ARGUMENTS 5
+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) \
     template <> \
+    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 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:
+        int numParams_;
+        bool hasReturnValue_;
+        FunctionType type_;
+        MultiTypeMath returnedValue_;
+        std::string typeReturnvalue_;
+        std::string typeParam_[5];
+};
+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_)
+    inline std::string typeToString<type>() { return #type; } \
+    template <> \
+    inline std::string typeToString<type&>() { return #type; } \
+    template <> \
+    inline std::string typeToString<const type>() { return #type; } \
+    template <> \
+    inline std::string typeToString<const 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(Vector2);
+    CreateTypeToStringTemplate(Vector3);
+    CreateTypeToStringTemplate(Quaternion);
+    CreateTypeToStringTemplate(ColourValue);
+    CreateTypeToStringTemplate(Radian);
+    CreateTypeToStringTemplate(Degree);
+    template <> \
+    inline std::string typeToString<std::string>() { return "string"; } \
+    template <> \
+    inline std::string typeToString<std::string&>() { return "string"; } \
+    template <> \
+    inline std::string typeToString<const std::string>() { return "string"; } \
+    template <> \
+    inline std::string typeToString<const std::string&>() { return "string"; }
+    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] : ""; }
+            std::string getTypenameReturnvalue() const { return this->typeReturnvalue_; }
+            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const = 0;
+        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_;
+};
+#define MAKE_COMMA(x) MAKE_COMMA##x
+#define MAKE_COMMA0
+#define MAKE_COMMA1 ,
+#define MAKE_COMMA2 ,
+#define MAKE_COMMA3 ,
+#define MAKE_COMMA4 ,
+#define MAKE_COMMA5 ,
+            void setObject(const T* object)
+            {
+                this->bConstObject_ = true;
+                this->constObject_ = object;
+            }
+        private:
+            const T* constObject_;
+            T* object_;
+            bool bConstObject_;
+    };
 …
+#define FUNCTOR_EVALUATE_PARAM(numparams) FUNCTOR_EVALUATE_PARAM##numparams
+#define FUNCTOR_EVALUATE_PARAM0
+#define FUNCTOR_EVALUATE_PARAM1 \
+    if (index == 0) param = (P1)param
+#define FUNCTOR_EVALUATE_PARAM2 \
+    if (index == 0) param = (P1)param; \
+    else if (index == 1) param = (P2)param
+#define FUNCTOR_EVALUATE_PARAM3 \
+    if (index == 0) param = (P1)param; \
+    else if (index == 1) param = (P2)param; \
+    else if (index == 2) param = (P3)param
+#define FUNCTOR_EVALUATE_PARAM4 \
+    if (index == 0) param = (P1)param; \
+    else if (index == 1) param = (P2)param; \
+    else if (index == 2) param = (P3)param; \
+    else if (index == 3) param = (P4)param
+#define FUNCTOR_EVALUATE_PARAM5 \
+    if (index == 0) param = (P1)param; \
+    else if (index == 1) param = (P2)param; \
+    else if (index == 2) param = (P3)param; \
+    else if (index == 3) param = (P4)param; \
+    else if (index == 4) param = (P5)param
 …
             } \
+    \
+            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            { \
+                FUNCTOR_EVALUATE_PARAM(numparams); \
+            } \
+    \
         private: \
             FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
 …
             } \
+    \
+            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            { \
+                FUNCTOR_EVALUATE_PARAM(numparams); \
+            } \
+    \
         private: \
             FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
 …
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
+            } \
+    \
+            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            { \
+                FUNCTOR_EVALUATE_PARAM(numparams); \
             } \
+    \
 …
+CREATE_ALL_STATIC_FUNCTORS();
+CREATE_ALL_MEMBER_FUNCTORS();
+    CREATE_ALL_STATIC_FUNCTORS();
+    CREATE_ALL_MEMBER_FUNCTORS();
+}
 #endif /* _Functor_H__ */

code/trunk/src/orxonox/core/Identifier.cc

-                      r871
+                      r1052
 #include "Identifier.h"
 #include "Factory.h"
+#include "Executor.h"
+#include "CommandExecutor.h"
 namespace orxonox
 …
         this->factory_ = 0;
+        this->children_ = new std::list<const Identifier*>();
+        this->directChildren_ = new std::list<const Identifier*>();
+        this->bHasConfigValues_ = false;
+        this->bHasConsoleCommands_ = false;
+        this->children_ = new std::set<const Identifier*>();
+        this->directChildren_ = new std::set<const Identifier*>();
         // Use a static variable because the classID gets created before main() and that's why we should avoid static member variables
 …
         @param parents A list containing all parents
     */
     void Identifier::initialize(std::list<const Identifier*>* parents)
+    void Identifier::initialize(std::set<const Identifier*>* parents)
+    {
         COUT(4) << "*** Identifier: Initialize " << this->name_ << "-Singleton." << std::endl;
 …
             // Iterate through all parents
             for (std::list<const Identifier*>::iterator it = parents->begin(); it != parents->end(); ++it)
+            for (std::set<const Identifier*>::iterator it = parents->begin(); it != parents->end(); ++it)
+            {
                 // Tell the parent we're one of it's children
 …
                 // Erase all parents of our parent from our direct-parent-list
                 for (std::list<const Identifier*>::const_iterator it1 = (*it)->getParents().begin(); it1 != (*it)->getParents().end(); ++it1)
+                for (std::set<const Identifier*>::const_iterator it1 = (*it)->getParents().begin(); it1 != (*it)->getParents().end(); ++it1)
+                {
                     // Search for the parent's parent in our direct-parent-list
                     for (std::list<const Identifier*>::iterator it2 = this->directParents_.begin(); it2 != this->directParents_.end(); ++it2)
+                    for (std::set<const Identifier*>::iterator it2 = this->directParents_.begin(); it2 != this->directParents_.end(); ++it2)
+                    {
                         if ((*it1) == (*it2))
 …
             // Now iterate through all direct parents
             for (std::list<const Identifier*>::iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+            for (std::set<const Identifier*>::iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+            {
                 // Tell the parent we're one of it's direct children
 …
     bool Identifier::isA(const Identifier* identifier) const
+    {
         return (identifier == this || this->identifierIsInList(identifier, this->parents_));
+        return (identifier == this || (this->parents_.find(identifier) != this->children_->end()));
+    }
 …
     bool Identifier::isChildOf(const Identifier* identifier) const
+    {
         return this->identifierIsInList(identifier, this->parents_);
+        return (this->parents_.find(identifier) != this->children_->end());
+    }
 …
     bool Identifier::isDirectChildOf(const Identifier* identifier) const
+    {
         return this->identifierIsInList(identifier, this->directParents_);
+        return (this->directParents_.find(identifier) != this->children_->end());
+    }
 …
     bool Identifier::isParentOf(const Identifier* identifier) const
+    {
         return this->identifierIsInList(identifier, *this->children_);
+        return (this->children_->find(identifier) != this->children_->end());
+    }
 …
     bool Identifier::isDirectParentOf(const Identifier* identifier) const
+    {
+        return this->identifierIsInList(identifier, *this->directChildren_);
+        return (this->directChildren_->find(identifier) != this->children_->end());
+    }
+    /**
+        @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 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 Searches for a given identifier in a list and returns whether the identifier is in the list or not.
+        @param identifier The identifier to look for
+        @param list The list
+        @return True = the identifier is in the list
+    */
+    bool Identifier::identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list)
+    {
+        for (std::list<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
+            if (identifier == (*it))
+                return true;
+        return false;
+    }
+    std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list)
+    {
+        for (std::list<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
+        @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)
+    {
+        for (std::set<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
             out << (*it)->getName() << " ";

code/trunk/src/orxonox/core/Identifier.h

-                      r1024
+                      r1052
 #define _Identifier_H__
 #include <list>
+#include <set>
 #include <map>
 #include <string>
 …
 #include "Debug.h"
 #include "Iterator.h"
+#include "util/String.h"
 namespace orxonox
 …
             bool isDirectParentOf(const Identifier* identifier) const;
+            /** @brief Removes all objects of the corresponding class. */
+            virtual void removeObjects() const = 0;
+            virtual const ObjectList<BaseObject>* getObjectList() const = 0;
+            virtual void updateConfigValues() const = 0;
             /** @brief Returns the name of the class the Identifier belongs to. @return The name */
             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::list<const Identifier*>& getParents() const { return this->parents_; }
+            inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
             /** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
+            inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
             /** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
             inline std::list<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
+            inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline const std::list<const Identifier*>& getChildren() const { return (*this->children_); }
+            inline const std::set<const Identifier*>& getChildren() const { return (*this->children_); }
             /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
+            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
             /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
             inline std::list<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
+            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
             /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
             inline const std::list<const Identifier*>& getDirectParents() const { return this->directParents_; }
+            inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
             /** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
+            inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
             /** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
             inline std::list<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
+            inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
             /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
             inline const std::list<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
+            inline const std::set<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
             /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
             inline std::list<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
+            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
             /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
+            inline std::list<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
+            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 */
 …
             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;
+            static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
+            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:
 …
             Identifier(const Identifier& identifier) {} // don't copy
             virtual ~Identifier();
             void initialize(std::list<const Identifier*>* parents);
+            void initialize(std::set<const Identifier*>* parents);
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline std::list<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
+            inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
             /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
             inline std::list<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
+            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
             /**
 …
+            }
+            std::list<const Identifier*> parents_;                      //!< The parents of the class the Identifier belongs to
+            std::list<const Identifier*>* children_;                    //!< The children of the class the Identifier belongs to
+            std::list<const Identifier*> directParents_;                //!< The direct parents of the class the Identifier belongs to
+            std::list<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
     };
     _CoreExport std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list);
+    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
 …
         public:
             ClassIdentifier<T>* registerClass(std::list<const Identifier*>* parents, const std::string& name, bool bRootClass);
+            ClassIdentifier<T>* registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass);
             void addObject(T* object);
-            void removeObjects() const;
             void setName(const std::string& name);
+            /** @brief Returns the list of all existing objects of this class. @return The list */
             inline const ObjectList<T>* getObjects() const { return this->objects_; }
+            /** @brief Returns a list of all existing objects of this class. @return The list */
+            inline const ObjectList<BaseObject>* getObjectList() const { return (ObjectList<BaseObject>*)this->objects_; }
+            void updateConfigValues() const;
             XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
 …
             ~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
     };
 …
     */
     template <class T>
     ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::list<const Identifier*>* parents, const std::string& name, bool bRootClass)
+    {
         COUT(5) << "*** ClassIdentifier: Register Class in " << name << "-Singleton." << std::endl;
+    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass)
+    {
+        this->setName(name);
         // Check if at least one object of the given type was created
         if (!this->bCreatedOneObject_)
+        if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
+        {
             // If no: We have to store the informations and initialize the Identifier
-            this->setName(name);
             COUT(4) << "*** ClassIdentifier: Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
             if (bRootClass)
 …
             this->name_ = name;
             this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
+        }
+    }
 …
     /**
+        @brief Removes all objects of the corresponding class.
+    */
+    template <class T>
+    void ClassIdentifier<T>::removeObjects() const
+    {
+        for (Iterator<T> it = this->objects_->start(); it;)
+            delete *(it++);
+    }
+        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
+    */
+    template <class T>
+    void ClassIdentifier<T>::updateConfigValues() const
+    {
+        for (Iterator<T> it = this->objects_->start(); it; ++it)
+            ((T*)*it)->setConfigValues();
+    }
+    /**
+        @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)
 …
+    }
+    /**
+        @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)
 …
+    }
+    /**
+        @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)
 …
+    }
+    /**
+        @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/trunk/src/orxonox/core/InputBuffer.cc

-                      r1051
+                      r1052
 #include "InputBuffer.h"
+#include "InputManager.h"
 #include "util/Clipboard.h"
 namespace orxonox
+{
     InputBuffer::InputBuffer(OIS::Keyboard* keyboard)
+    InputBuffer::InputBuffer()
+    {
         this->bActivated_ = false;
         this->allowedChars_ = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZäöüÄÖÜ0123456789 \\\"().:,;_-+*/=!?<>[|]";
         this->keyboard_ = keyboard;
+        this->keyboard_ = InputManager::getSingleton().getKeyboard();
         this->buffer_ = "";

code/trunk/src/orxonox/core/InputBuffer.h

r1051	r1052
58	58
59	59	public:
60		InputBuffer(~~OIS::Keyboard* keyboard~~);
	60	InputBuffer();
61	61
62	62	template <class T>

code/trunk/src/orxonox/core/InputHandler.cc

r1024	r1052
66	66	{
67	67	// simply write the key number (i) in the string
68		this->bindingsKeyPressed_[i] = ~~ConvertValueAndReturn~~<int, std::string>(i);
69		this->bindingsKeyReleased_[i] = ~~ConvertValueAndReturn~~<int, std::string>(i);
	68	this->bindingsKeyPressed_[i] = getConvertedValue<int, std::string>(i);
	69	this->bindingsKeyReleased_[i] = getConvertedValue<int, std::string>(i);
70	70	}
71	71	return true;

code/trunk/src/orxonox/core/Language.cc

-                      r871
+                      r1052
 /**
     @file Language.cc
     @brief Implementation of the Language and the LanguageEntry class.
+    @brief Implementation of the Language and the LanguageEntry classes.
 */
 #include <fstream>
-#include "CoreIncludes.h"
 #include "Language.h"
+#include "CoreSettings.h"
 namespace orxonox
 …
     LanguageEntry::LanguageEntry(const std::string& fallbackEntry)
+    {
-        RegisterRootObject(LanguageEntry);
         this->fallbackEntry_ = fallbackEntry;
         this->localisedEntry_ = fallbackEntry; // Set the localisation to the fallback entry, for the case that no translation gets assigned
 …
+    {
         // Check if the translation is more than just an empty string
         if (localisation.compare("") != 0)
+        if ((localisation != "") && (localisation.size() > 0))
+        {
             this->localisedEntry_ = localisation;
 …
     Language::Language()
+    {
-        RegisterRootObject(Language);
         this->defaultLanguage_ = "default";
         this->defaultLocalisation_ = "ERROR: LANGUAGE ENTRY DOESN'T EXIST!";
 …
     /**
-        @brief Function to collect the SetConfigValue-macro calls.
-    */
-    void Language::setConfigValues()
+    {
-        SetConfigValue(language_, this->defaultLanguage_).description("The language of the ingame text");
-        // Read the translation file after the language was configured
-        this->readTranslatedLanguageFile();
+    }
-    /**
         @brief Returns a reference to the only existing instance of the Language class and calls the setConfigValues() function.
         @return The reference to the only existing instance
 …
     Language& Language::getLanguage()
+    {
+        // Use static variables to avoid conflicts while executing this code before main()
+        static Language theOnlyLanguageObject = Language();
+        static bool bCreatingTheOnlyLanguageObject = true;
+        // This workaround is used to set a description of the own config value without creating an infinite recursion
+        if (bCreatingTheOnlyLanguageObject)
+        {
+            bCreatingTheOnlyLanguageObject = false;
+            theOnlyLanguageObject.setConfigValues();
+        }
+        return theOnlyLanguageObject;
+        static Language instance = Language();
+        return instance;
+    }
 …
             // Check if the line is empty
             if (lineString.compare("") != 0)
+            if ((lineString != "") && (lineString.size() > 0))
+            {
                 unsigned int pos = lineString.find('=');
 …
                     this->createEntry(lineString.substr(0, pos), lineString.substr(pos + 1));
                 else
+                {
                     COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFileName(this->defaultLanguage_) << std::endl;
+                }
+            }
+        }
 …
     void Language::readTranslatedLanguageFile()
+    {
         COUT(4) << "Read translated language file (" << this->language_ << ")." << std::endl;
+        COUT(4) << "Read translated language file (" << CoreSettings::getLanguage() << ")." << std::endl;
         // Open the file
         std::ifstream file;
         file.open(getFileName(this->language_).c_str(), std::fstream::in);
+        file.open(getFileName(CoreSettings::getLanguage()).c_str(), std::fstream::in);
         if (!file.is_open())
+        {
             COUT(1) << "An error occurred in Language.cc:" << std::endl;
             COUT(1) << "Error: Couldn't open file " << getFileName(this->language_) << " to read the translated language entries!" << std::endl;
             ResetConfigValue(language_);
+            COUT(1) << "Error: Couldn't open file " << getFileName(CoreSettings::getLanguage()) << " to read the translated language entries!" << std::endl;
+            CoreSettings::resetLanguage();
             COUT(3) << "Info: Reset language to " << this->defaultLanguage_ << "." << std::endl;
             return;
 …
             // Check if the line is empty
             if (lineString.compare("") != 0)
+            if ((lineString != "") && (lineString.size() > 0))
+            {
                 unsigned int pos = lineString.find('=');
 …
+                }
                 else
+                    COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFileName(this->language_) << std::endl;
+                {
+                    COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFileName(CoreSettings::getLanguage()) << std::endl;
+                }
+            }
+        }
 …
         // Iterate through the list an write the lines into the file
         for (Iterator<LanguageEntry> it = ObjectList<LanguageEntry>::start(); it; ++it)
+        {
             file << it->getLabel() << "=" << it->getDefault() << std::endl;
+        for (std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
+        {
+            file << (*it).second->getLabel() << "=" << (*it).second->getDefault() << std::endl;
+        }

code/trunk/src/orxonox/core/Language.h

-                      r871
+                      r1052
 #include "CorePrereqs.h"
-#include "OrxonoxClass.h"
 …
     // ###############################
     //! The LanguageEntry class stores the default- and the translated string of a given entry in the language file.
     class _CoreExport LanguageEntry : public OrxonoxClass
+    class _CoreExport LanguageEntry
+    {
         public:
 …
     // ###############################
     //! The Language class manges the language files and entries and stores the LanguageEntry objects in a map.
     class _CoreExport Language : public OrxonoxClass
+    class _CoreExport Language
+    {
+        template <class T>
+        friend class ClassIdentifier; // forward declaration because of the private destructor
+        friend class CoreSettings;
         public:
             static Language& getLanguage();
-            void setConfigValues();
             void addEntry(const LanguageEntryLabel& label, const std::string& entry);
             const std::string& getLocalisation(const LanguageEntryLabel& label) const;
 …
             LanguageEntry* createEntry(const LanguageEntryLabel& label, const std::string& entry);
-            std::string language_;                                  //!< The configured language
             std::string defaultLanguage_;                           //!< The default language
             std::string defaultLocalisation_;                       //!< The returned string, if an entry unavailable entry is requested

code/trunk/src/orxonox/core/Loader.cc

-                      r1021
+                      r1052
 #include "CoreIncludes.h"
 #include "Script.h"
+#include "Namespace.h"
 #include "util/tinyxml/ticpp.h"
 …
             xmlfile.Parse(lua->getLuaOutput(), true);
+            for ( ticpp::Iterator<ticpp::Element> child = xmlfile.FirstChildElement(false); child != child.end(); child++ )
+            {
+                Identifier* identifier = ID(child->Value());
+                if (identifier)
+                {
+                    if (Loader::currentMask_s.isIncluded(identifier))
+                    {
+                        COUT(4) << "  fabricating " << child->Value() << "..." << std::endl;
+                        BaseObject* newObject = identifier->fabricate();
+                        newObject->setLoaderIndentation("    ");
+                        newObject->setLevel(level);
+                        newObject->XMLPort(*child, true);
+                        COUT(5) << "  ...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::endl;
+                    }
+                }
+                else
+                {
+                    COUT(2) << "  Warning: '" << child->Value() << "' is not a valid classname." << std::endl;
+                }
+            }
+            ticpp::Element rootElement;
+            rootElement.SetAttribute("name", "root");
+            rootElement.SetAttribute("bAutogenerated", true);
+            for (ticpp::Iterator<ticpp::Element> child = xmlfile.FirstChildElement(false); child != child.end(); child++)
+                rootElement.InsertEndChild(*child);
+            COUT(4) << "  creating root-namespace..." << std::endl;
+            Namespace* rootNamespace = new Namespace();
+            rootNamespace->setLoaderIndentation("    ");
+            rootNamespace->setLevel(level);
+            rootNamespace->setNamespace(rootNamespace);
+            rootNamespace->setRoot(true);
+            rootNamespace->XMLPort(rootElement, XMLPort::LoadObject);
             COUT(0) << "Finished loading " << level->getFile() << "." << std::endl;
+            COUT(4) << "Namespace-tree:" << std::endl << rootNamespace->toString("  ") << std::endl;
             return true;

code/trunk/src/orxonox/core/MetaObjectList.h

r1024	r1052
99	99
100	100
101		COUT(5) << "*** MetaObjectList: Removing Object from " << ~~this->element_->object_->~~getIdentifier()->getName() << "-list." << std::endl;
	101	COUT(5) << "*** MetaObjectList: Removing Object from " << ClassManager<T>::getIdentifier()->getName() << "-list." << std::endl;
102	102	delete this->element_;
103	103	}

code/trunk/src/orxonox/core/OrxonoxClass.h

-                      r871
+                      r1052
 #define _OrxonoxClass_H__
 #include <list>
+#include <set>
 #include <string>
 …
             /** @brief Returns the list of all parents of the object. @return The list */
             inline std::list<const Identifier*>* getParents() const { return this->parents_; }
+            inline std::set<const Identifier*>* getParents() const { return this->parents_; }
             /** @brief Creates the parents-list. */
             inline void createParents() { this->parents_ = new std::list<const Identifier*>(); }
+            inline void createParents() { this->parents_ = new std::set<const Identifier*>(); }
             /** @brief Returns the MetaObjectList of the object, containing a link to all ObjectLists and ObjectListElements the object is registered in. @return The list */
 …
         private:
             Identifier* identifier_;                    //!< The Identifier of the object
             std::list<const Identifier*>* parents_;     //!< List of all parents of the object
+            std::set<const Identifier*>* parents_;     //!< List of all parents of the object
             MetaObjectList metaList_;                   //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
     };

code/trunk/src/orxonox/core/OutputHandler.cc

-                      r871
+                      r1052
 */
 #include "DebugLevel.h"
+#include "CoreSettings.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.
 …
         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();
+    }
 …
     int OutputHandler::getSoftDebugLevel(OutputHandler::OutputDevice device)
+    {
         return DebugLevel::getSoftDebugLevel(device);
+        return CoreSettings::getSoftDebugLevel(device);
+    }

code/trunk/src/orxonox/core/OutputHandler.h

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

code/trunk/src/orxonox/core/Tickable.cc

r1021	r1052
27	27
28	28	#include "core/CoreIncludes.h"
	29	#include "core/ConsoleCommand.h"
29	30	#include "Tickable.h"
30	31

code/trunk/src/orxonox/core/XMLPort.cc

-                      r871
+                      r1052
 #include "Language.h"
 #include "Loader.h"
+#include "Namespace.h"
+#include "CoreIncludes.h"
 namespace orxonox
+{
-    // ###############################
-    // ###  XMLPortParamContainer  ###
-    // ###############################
-    XMLPortParamContainer::XMLPortParamContainer()
+    {
-        this->bAddedDescription_ = false;
-        this->bAddedDefaultValues_ = false;
+    }
-    XMLPortParamContainer& XMLPortParamContainer::description(const std::string description)
+    {
-        if (!this->bAddedDescription_)
+        {
-            this->description_ = std::string("XMLPortParamContainer::" + this->classname_ + "::" + this->paramname_);
-            AddLanguageEntry(this->description_, description);
-            this->bAddedDescription_ = true;
+        }
-        return (*this);
+    }
-    const std::string& XMLPortParamContainer::getDescription()
+    {
-        return GetLocalisation(this->description_);
+    }
     // ################################
     // ###  XMLPortObjectContainer  ###
     // ################################
-    XMLPortObjectContainer::XMLPortObjectContainer()
+    {
-        this->bAddedDescription_ = false;
+    }
-    XMLPortObjectContainer& XMLPortObjectContainer::description(const std::string description)
+    {
-        if (!this->bAddedDescription_)
+        {
-            this->description_ = std::string("XMLPortObjectContainer::" + this->classname_ + "::" + this->sectionname_);
-            AddLanguageEntry(this->description_, description);
-            this->bAddedDescription_ = true;
+        }
-        return (*this);
+    }
-    const std::string& XMLPortObjectContainer::getDescription()
+    {
-        return GetLocalisation(this->description_);
+    }
     bool XMLPortObjectContainer::identifierIsIncludedInLoaderMask(const Identifier* identifier)
+    {
         return Loader::currentMask_s.isIncluded(identifier);
+        return ((!this->bApplyLoaderMask_) || identifier->isA(Class(Namespace)) || Loader::currentMask_s.isIncluded(identifier));
+    }
+}

code/trunk/src/orxonox/core/XMLPort.h

-                      r871
+                      r1052
 #include "util/MultiTypeMath.h"
 #include "util/tinyxml/ticpp.h"
+#include "util/SubString.h"
+#include "Functor.h"
+#include "Executor.h"
 #include "Debug.h"
 #include "CoreIncludes.h"
 …
+#define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, loading) \
+    orxonox::XMLPortClassParamContainer<classname>* xmlcontainer##loadfunction##savefunction = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
+    if (!xmlcontainer##loadfunction##savefunction) \
+#define XMLPortParam(classname, paramname, loadfunction, 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, 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, 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, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
+#define XMLPortParamGeneric(containername, classname, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
+    orxonox::XMLPortClassParamContainer<classname>* containername = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
+    if (!containername) \
     { \
         xmlcontainer##loadfunction##savefunction = new orxonox::XMLPortClassParamContainer<classname>(this->getIdentifier()->getName(), std::string(paramname), createFunctor(&classname::loadfunction), createFunctor(&classname::savefunction)); \
         this->getIdentifier()->addXMLPortParamContainer(paramname, xmlcontainer##loadfunction##savefunction); \
+        containername = new orxonox::XMLPortClassParamContainer<classname>(std::string(paramname), loadexecutor, saveexecutor); \
+        this->getIdentifier()->addXMLPortParamContainer(paramname, containername); \
     } \
+    xmlcontainer##loadfunction##savefunction->port(this, xmlelement, loading)
+#define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, loading) \
+    orxonox::XMLPortClassParamContainer<classname>* xmlcontainer##loadfunction##savefunction = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
+    if (!xmlcontainer##loadfunction##savefunction) \
+    containername->port(this, xmlelement, mode)
+#define XMLPortObject(classname, objectclass, sectionname, loadfunction, 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, 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) \
+    orxonox::XMLPortClassObjectContainer<classname, objectclass>* containername = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(this->getIdentifier()->getXMLPortObjectContainer(sectionname)); \
+    if (!containername) \
     { \
         xmlcontainer##loadfunction##savefunction = new orxonox::XMLPortClassParamContainer<classname>(this->getIdentifier()->getName(), std::string(paramname), createFunctor(&classname::loadfunction), 0); \
         this->getIdentifier()->addXMLPortParamContainer(paramname, xmlcontainer##loadfunction##savefunction); \
+        containername = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(std::string(sectionname), loadexecutor, saveexecutor, bApplyLoaderMask, bLoadBefore); \
+        this->getIdentifier()->addXMLPortObjectContainer(sectionname, containername); \
     } \
+    xmlcontainer##loadfunction##savefunction->port(this, xmlelement, loading)
+#define XMLPortObject(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, loading) \
+    orxonox::XMLPortClassObjectContainer<classname, objectclass>* xmlcontainer##loadfunction##savefunction = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(this->getIdentifier()->getXMLPortObjectContainer(sectionname)); \
+    if (!xmlcontainer##loadfunction##savefunction) \
+    { \
+        xmlcontainer##loadfunction##savefunction = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(this->getIdentifier()->getName(), std::string(sectionname), &classname::loadfunction, &classname::savefunction); \
+        this->getIdentifier()->addXMLPortObjectContainer(sectionname, xmlcontainer##loadfunction##savefunction); \
+    } \
+    xmlcontainer##loadfunction##savefunction->port(this, xmlelement, loading)
+    containername->port(this, xmlelement, mode)
 namespace orxonox
+{
+#ifndef _XMLPort_Mode__
+#define _XMLPort_Mode__
+    namespace XMLPort
+    {
+        enum Mode
+        {
+            LoadObject,
+            SaveObject
+        };
+    }
+#endif
     // ###############################
     // ###  XMLPortParamContainer  ###
 …
     class _CoreExport XMLPortParamContainer
+    {
+        enum ParseResult
+        {
+            PR_not_started,
+            PR_finished,
+            PR_waiting_for_default_values
+        };
         public:
+            XMLPortParamContainer();
+            XMLPortParamContainer()
+                { this->parseResult_ = PR_not_started; }
+            virtual ~XMLPortParamContainer() {}
             inline const std::string& getName() const
                 { return this->paramname_; }
+            XMLPortParamContainer& description(const std::string description);
+            const std::string& getDescription();
+            XMLPortParamContainer& defaultValues(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)
+            {
+                this->defaultValues_[0] = param1;
+                this->defaultValues_[1] = param2;
+                this->defaultValues_[2] = param3;
+                this->defaultValues_[3] = param4;
+                this->defaultValues_[4] = param5;
+                return (*this);
+            }
+            virtual XMLPortParamContainer& description(const std::string description) = 0;
+            virtual const std::string& getDescription() = 0;
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) = 0;
         protected:
-            std::string classname_;
             std::string paramname_;
+            MultiTypeMath defaultValues_[5];
+        private:
+            LanguageEntryLabel description_;
+            bool bAddedDescription_;
+            bool bAddedDefaultValues_;
+            ParseResult parseResult_;
     };
 …
     class XMLPortClassParamContainer : public XMLPortParamContainer
+    {
+        struct ParseParams
+        {
+            T* object;
+            Element* xmlelement;
+            XMLPort::Mode mode;
+        };
         public:
+            XMLPortClassParamContainer(const std::string classname, const std::string paramname, FunctorMember<T>* loadfunction, FunctorMember<T>* savefunction)
+            {
+                this->classname_ = classname;
+            XMLPortClassParamContainer(const std::string paramname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
+            {
                 this->paramname_ = paramname;
+                this->loadfunction_ = loadfunction;
+                this->savefunction_ = savefunction;
+            }
+            XMLPortParamContainer& port(T* object, Element& xmlelement, bool loading)
+            {
+                if (loading)
+                this->loadexecutor_ = loadexecutor;
+                this->saveexecutor_ = saveexecutor;
+            }
+            XMLPortParamContainer& port(T* object, Element& xmlelement, XMLPort::Mode mode)
+            {
+                this->parseParams_.object = object;
+                this->parseParams_.xmlelement = &xmlelement;
+                this->parseParams_.mode = mode;
+                if (mode == XMLPort::LoadObject)
+                {
                     try
+                    {
                         std::string attribute = xmlelement.GetAttribute(this->paramname_);
                         if (attribute.size() > 0)
+                        if ((attribute.size() > 0) || (this->loadexecutor_->allDefaultValuesSet()))
+                        {
+                            SubString tokens(attribute, ",", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+                            if ((unsigned int)tokens.size() >= (unsigned int)this->loadfunction_->getParamCount())
+                            {
+                                COUT(5) << object->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->classname_ << " (objectname " << object->getName() << ") with ";
+                                if (this->loadfunction_->getParamCount() == 1)
+                                {
+                                    COUT(5) << "1 parameter (using whole string):" << std::endl;
+                                    COUT(5) << object->getLoaderIndentation() << "  " << attribute << std::endl;
+                                    (*this->loadfunction_)(object, MultiTypeMath(attribute));
+                                }
+                                else
+                                {
+                                    COUT(5) << tokens.size() << " parameter (using MultiTypeMath)." << std::endl;
+                                    MultiTypeMath param1 = MT_null, param2 = MT_null, param3 = MT_null, param4 = MT_null, param5 = MT_null;
+                                    if (tokens.size() >= 1) param1 = tokens[0];
+                                    if (tokens.size() >= 2) param2 = tokens[1];
+                                    if (tokens.size() >= 3) param3 = tokens[2];
+                                    if (tokens.size() >= 4) param4 = tokens[3];
+                                    if (tokens.size() >= 5) param5 = tokens[4];
+                                    COUT(5) << object->getLoaderIndentation() << "  " << attribute << std::endl;
+                                    COUT(5) << object->getLoaderIndentation() << "  " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << std::endl;
+                                    (*this->loadfunction_)(object, param1, param2, param3, param4, param5);
+                                }
+                            }
+                            COUT(5) << object->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << object->getIdentifier()->getName() << " (objectname " << object->getName() << ")." << std::endl << object->getLoaderIndentation();
+                            if (this->loadexecutor_->parse(object, attribute, ","))
+                                this->parseResult_ = PR_finished;
                             else
+                            {
+                                COUT(2) << object->getLoaderIndentation() << "Warning: Parameter \"" << this->paramname_ << "\" in \"" << this->classname_ << "\" (objectname: " << object->getName() << ") is incomplete and couln't be loaded." << std::endl;
+                            }
+                                this->parseResult_ = PR_waiting_for_default_values;
+                        }
+                    }
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->classname_ << "' (objectname: " << object->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << object->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }
 …
                 else
+                {
                     if (this->savefunction_)
+                    if (this->saveexecutor_)
+                    {
 //                        xmlelement.SetAttribute(this->paramname_, "...");
 …
+            }
+            XMLPortParamContainer& port(const ParseParams& parseParams)
+            {
+                return this->port(parseParams.object, *parseParams.xmlelement, parseParams.mode);
+            }
+            XMLPortParamContainer& portIfWaitingForDefaultValues(const ParseResult& result, const ParseParams& params)
+            {
+                if (result == PR_waiting_for_default_values)
+                    return this->port(params);
+                else
+                    return (*this);
+            }
+            virtual XMLPortParamContainer& description(const std::string description)
+                { this->loadexecutor_->setDescription(description); return (*this); }
+            virtual const std::string& getDescription()
+                { return this->loadexecutor_->getDescription(); }
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param)
+            {
+                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->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->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->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->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->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_);
+            }
         private:
+            FunctorMember<T>* loadfunction_;
+            FunctorMember<T>* savefunction_;
+            ExecutorMember<T>* loadexecutor_;
+            ExecutorMember<T>* saveexecutor_;
+            ParseParams parseParams_;
     };
 …
+    {
         public:
+            XMLPortObjectContainer();
+            XMLPortObjectContainer()
+                { this->bApplyLoaderMask_ = false; }
+            virtual ~XMLPortObjectContainer() {}
             inline const std::string& getName() const
                 { return this->sectionname_; }
+            XMLPortObjectContainer& description(const std::string description);
+            const std::string& getDescription();
+            static bool identifierIsIncludedInLoaderMask(const Identifier* identifier);
+            virtual XMLPortObjectContainer& description(const std::string description) = 0;
+            virtual const std::string& getDescription() = 0;
+            bool identifierIsIncludedInLoaderMask(const Identifier* identifier);
         protected:
-            std::string classname_;
             std::string sectionname_;
+        private:
+            LanguageEntryLabel description_;
+            bool bAddedDescription_;
+            bool bApplyLoaderMask_;
+            bool bLoadBefore_;
     };
 …
+    {
         public:
+            XMLPortClassObjectContainer(const std::string classname, const std::string sectionname, void (T::*loadfunction)(O*), const O* (T::*savefunction)(unsigned int))
+            {
+                this->classname_ = classname;
+            XMLPortClassObjectContainer(const std::string sectionname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
+            {
                 this->sectionname_ = sectionname;
+                this->loadfunction_ = loadfunction;
+                this->savefunction_ = savefunction;
+            }
+            XMLPortObjectContainer& port(T* object, Element& xmlelement, bool loading)
+            {
+                if (loading)
+                this->loadexecutor_ = loadexecutor;
+                this->saveexecutor_ = saveexecutor;
+                this->bApplyLoaderMask_ = bApplyLoaderMask;
+                this->bLoadBefore_ = bLoadBefore;
+            }
+            XMLPortObjectContainer& port(T* object, Element& xmlelement, XMLPort::Mode mode)
+            {
+                if (mode == XMLPort::LoadObject)
+                {
                     try
+                    {
+                        Element* xmlsubelement = xmlelement.FirstChildElement(this->sectionname_, false);
+                        Element* xmlsubelement;
+                        if ((this->sectionname_ != "") && (this->sectionname_.size() > 0))
+                            xmlsubelement = xmlelement.FirstChildElement(this->sectionname_, false);
+                        else
+                            xmlsubelement = &xmlelement;
                         if (xmlsubelement)
+                        {
                             for ( ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++ )
+                            for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
+                            {
                                 Identifier* identifier = ID(child->Value());
 …
+                                        {
                                             COUT(4) << object->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::endl;
                                             O* newObject = (O*)identifier->fabricate();
                                             newObject->setLoaderIndentation(object->getLoaderIndentation() + "  ");
                                             newObject->setLevel(object->getLevel());
+                                            newObject->XMLPort(*child, true);
+                                            COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->classname_ << " (objectname " << object->getName() << ")" << std::endl;
+                                            (*object.*this->loadfunction_)(newObject);
+                                            COUT(5) << "  ...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::endl;
+                                            newObject->setNamespace(object->getNamespace());
+                                            if (this->bLoadBefore_)
+                                            {
+                                                newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << object->getIdentifier()->getName() << " (objectname " << object->getName() << ")" << std::endl;
+                                            }
+                                            else
+                                            {
+                                                COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << object->getIdentifier()->getName() << " (objectname " << object->getName() << ")" << std::endl;
+                                            }
+                                            COUT(5) << object->getLoaderIndentation();
+                                            (*this->loadexecutor_)(object, newObject);
+                                            if (!this->bLoadBefore_)
+                                                newObject->XMLPort(*child, XMLPort::LoadObject);
+                                            COUT(5) << object->getLoaderIndentation() << "...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::endl;
+                                        }
+                                    }
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << this->classname_ << "' (objectname: " << object->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << object->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }
 …
+            }
+            virtual XMLPortObjectContainer& description(const std::string description)
+                { this->loadexecutor_->setDescription(description); return (*this); }
+            virtual const std::string& getDescription()
+                { return this->loadexecutor_->getDescription(); }
         private:
             void     (T::*loadfunction_)(O*);
             const O* (T::*savefunction_)(unsigned int);
+            ExecutorMember<T>* loadexecutor_;
+            ExecutorMember<T>* saveexecutor_;
     };
+}

code/trunk/src/orxonox/objects/Ambient.cc

r1039	r1052
42	42	#include "GraphicsEngine.h"
43	43	#include "core/XMLPort.h"
	44	#include "core/ConsoleCommand.h"
44	45
45	46	namespace orxonox
46	47	{
	48	ConsoleCommand(Ambient, setAmbientLightTest, AccessLevel::Offline, false).setDefaultValues(ColourValue(1, 1, 1, 1));
	49
47	50	CreateFactory(Ambient);
	51
	52	Ambient* Ambient::instance_s;
48	53
49	54	Ambient::Ambient()
50	55	{
51	56	RegisterObject(Ambient);
	57	Ambient::instance_s = this;
52	58	}
53	59
…	…
84	90	@return The XML-element
85	91	*/
86		void Ambient::XMLPort(Element& xmlelement, ~~bool loading~~)
	92	void Ambient::XMLPort(Element& xmlelement, XMLPort::Mode mode)
87	93	{
88		BaseObject::XMLPort(xmlelement, ~~loading~~);
	94	BaseObject::XMLPort(xmlelement, mode);
89	95
90		XMLPortParamLoadOnly(Ambient, "colourvalue", setAmbientLight, xmlelement, ~~loading~~);
	96	XMLPortParamLoadOnly(Ambient, "colourvalue", setAmbientLight, xmlelement, mode);
91	97	}
92	98	}

code/trunk/src/orxonox/objects/Ambient.h

-                      r1040
+                      r1052
             void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, bool loading);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             void setAmbientLight(const ColourValue& colour);
+            static void setAmbientLightTest(const ColourValue& colour)
+                { Ambient::instance_s->setAmbientLight(colour); }
         private:
+            static Ambient* instance_s;
     };

code/trunk/src/orxonox/objects/Explosion.cc

-                      r1039
+                      r1052
 #include "core/CoreIncludes.h"
+#include "core/Executor.h"
 #include "util/Math.h"
 #include "GraphicsEngine.h"
 …
         if (owner)
+        {
             this->destroyTimer_.setTimer(this->lifetime_, false, this, &Explosion::destroyObject);
+            this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Explosion::destroyObject)));
             Vector3 position = owner->getNode()->getWorldPosition();

code/trunk/src/orxonox/objects/Model.cc

-                      r1039
+                      r1052
         @return The XML-element
     */
     void Model::XMLPort(Element& xmlelement, bool loading)
+    void Model::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         WorldEntity::XMLPort(xmlelement, loading);
+        WorldEntity::XMLPort(xmlelement, mode);
         XMLPortParamLoadOnly(Model, "mesh", setMesh, xmlelement, loading);
+        XMLPortParamLoadOnly(Model, "mesh", setMesh, xmlelement, mode);
         create();
 …
     bool Model::create(){
       WorldEntity::create();
+      if(meshSrc_.compare("")!=0){
+      if ((this->meshSrc_ != "") && (this->meshSrc_.size() > 0))
+      {
         this->mesh_.setMesh(meshSrc_);
         this->attachObject(this->mesh_.getEntity());

code/trunk/src/orxonox/objects/Model.h

r1039	r1052
43	43	virtual ~Model();
44	44	virtual void loadParams(TiXmlElement* xmlElem);
45		virtual void XMLPort(Element& xmlelement, ~~bool loading~~);
	45	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
46	46	void setMesh(const std::string& meshname);
47	47	bool create();

code/trunk/src/orxonox/objects/Projectile.cc

-                      r1039
+                      r1052
 #include "Projectile.h"
+#include "../core/CoreIncludes.h"
+#include "core/CoreIncludes.h"
+#include "core/Executor.h"
+#include "core/ConfigValueIncludes.h"
 #include "SpaceShip.h"
 #include "Explosion.h"
 …
+        }
         this->destroyTimer_.setTimer(this->lifetime_, false, this, &Projectile::destroyObject);
+        this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
+    }
 …
         SetConfigValue(lifetime_, 10.0).description("The time in seconds a projectile stays alive");
         SetConfigValue(speed_, 2000.0).description("The speed of a projectile in units per second");
+        this->setVelocity(Vector3(1, 0, 0) * this->speed_);
+    }

code/trunk/src/orxonox/objects/Skybox.cc

r1039	r1052
76	76	@return The XML-element
77	77	*/
78		void Skybox::XMLPort(Element& xmlelement, ~~bool loading~~)
	78	void Skybox::XMLPort(Element& xmlelement, XMLPort::Mode mode)
79	79	{
80		BaseObject::XMLPort(xmlelement, ~~loading~~);
	80	BaseObject::XMLPort(xmlelement, mode);
81	81
82		XMLPortParamLoadOnly(Skybox, "src", setSkybox, xmlelement, ~~loading~~);
	82	XMLPortParamLoadOnly(Skybox, "src", setSkybox, xmlelement, mode);
83	83	}
84	84	}

code/trunk/src/orxonox/objects/Skybox.h

r1039	r1052
15	15
16	16	void loadParams(TiXmlElement* xmlElem);
17		virtual void XMLPort(Element& xmlelement, ~~bool loading~~);
	17	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
18	18	void setSkybox(const std::string& skyboxname);
19	19

code/trunk/src/orxonox/objects/SpaceShip.cc

-                      r1039
+                      r1052
 #include "util/Math.h"
 #include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
 #include "core/Debug.h"
 #include "GraphicsEngine.h"
 …
 #include "Projectile.h"
 #include "core/XMLPort.h"
+#include "core/ConsoleCommand.h"
 namespace orxonox
+{
+    ConsoleCommand(SpaceShip, setMaxSpeedTest, AccessLevel::Debug, false);
+    ConsoleCommandGeneric(test1, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed", AccessLevel::Debug), false);
+    ConsoleCommandGeneric(test2, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber", AccessLevel::Debug), false);
+    ConsoleCommandGeneric(test3, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl", AccessLevel::Debug), false);
     CreateFactory(SpaceShip);
+    SpaceShip* SpaceShip::instance_s;
     SpaceShip::SpaceShip()
 …
         RegisterObject(SpaceShip);
         this->registerAllVariables();
+        SpaceShip::instance_s = this;
         this->setConfigValues();
 …
         @return The XML-element
     */
     void SpaceShip::XMLPort(Element& xmlelement, bool loading)
+    {
         Model::XMLPort(xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "camera", setCamera, xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "maxSpeed", setMaxSpeed, xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "maxRotation", setMaxRotation, xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "transAcc", setTransAcc, xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "rotAcc", setRotAcc, xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "transDamp", setTransDamp, xmlelement, loading);
         XMLPortParamLoadOnly(SpaceShip, "rotDamp", setRotDamp, xmlelement, loading);
+    void SpaceShip::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        Model::XMLPort(xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "camera", setCamera, xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "maxSpeed", setMaxSpeed, xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "maxRotation", setMaxRotation, xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "transAcc", setTransAcc, xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "rotAcc", setRotAcc, xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "transDamp", setTransDamp, xmlelement, mode);
+        XMLPortParamLoadOnly(SpaceShip, "rotDamp", setRotDamp, xmlelement, mode);
+    }

code/trunk/src/orxonox/objects/SpaceShip.h

-                      r1039
+                      r1052
             void setConfigValues();
             virtual void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, bool loading);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
 …
             void setRotDamp(float value);
+            static void setMaxSpeedTest(float value)
+                { SpaceShip::instance_s->setMaxSpeed(value); }
             bool mouseMoved(const OIS::MouseEvent &e);
             bool mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id);
 …
         private:
+            static SpaceShip* instance_s;
             Vector3 testvector_;
             bool bInvertYAxis_;

code/trunk/src/orxonox/objects/WorldEntity.cc

-                      r1039
+                      r1052
         @return The XML-element
     */
     void WorldEntity::XMLPort(Element& xmlelement, bool loading)
+    {
         BaseObject::XMLPort(xmlelement, loading);
         XMLPortParam(WorldEntity, "position", setPositionLoader2, getPosition, xmlelement, loading);
         XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionLoader, xmlelement, loading);
         XMLPortParamLoadOnly(WorldEntity, "yawpitchroll", setYawPitchRoll, xmlelement, loading);
         XMLPortParam(WorldEntity, "scale", setTotalScale, getScale, xmlelement, loading);
         XMLPortParam(WorldEntity, "rotationAxis", setRotationAxisLoader, getRotationAxis, xmlelement, loading);
         XMLPortParam(WorldEntity, "rotationRate", setRotationRate, getRotationRate, xmlelement, loading);
         XMLPortObject(WorldEntity, WorldEntity, "attached", attachWorldEntity, getAttachedWorldEntity, xmlelement, loading);
+    void WorldEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        BaseObject::XMLPort(xmlelement, mode);
+        XMLPortParam(WorldEntity, "position", setPositionLoader2, getPosition, xmlelement, mode);
+        XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionLoader, xmlelement, mode);
+        XMLPortParamLoadOnly(WorldEntity, "yawpitchroll", setYawPitchRoll, xmlelement, mode);
+        XMLPortParam(WorldEntity, "scale", setTotalScale, getScale, xmlelement, mode);
+        XMLPortParam(WorldEntity, "rotationAxis", setRotationAxisLoader, getRotationAxis, xmlelement, mode);
+        XMLPortParam(WorldEntity, "rotationRate", setRotationRate, getRotationRate, xmlelement, mode);
+        XMLPortObject(WorldEntity, WorldEntity, "attached", attachWorldEntity, getAttachedWorldEntity, xmlelement, mode, false, true);
+    }
 …
+    }
     const WorldEntity* WorldEntity::getAttachedWorldEntity(unsigned int index)
+    const WorldEntity* WorldEntity::getAttachedWorldEntity(unsigned int index) const
+    {
         if (index < this->attachedWorldEntities_.size())

code/trunk/src/orxonox/objects/WorldEntity.h

-                      r1039
+                      r1052
             virtual void tick(float dt);
             virtual void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, bool loading);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             inline bool create(){ return true; }
             void attachWorldEntity(WorldEntity* entity);
             const WorldEntity* getAttachedWorldEntity(unsigned int index);
+            const WorldEntity* getAttachedWorldEntity(unsigned int index) const;
             inline Ogre::SceneNode* getNode()

code/trunk/src/orxonox/tools/Timer.cc

-                      r1039
+                      r1052
 #include "OrxonoxStableHeaders.h"
+#include "core/Executor.h"
+#include "core/CoreIncludes.h"
+#include "core/ConsoleCommand.h"
+#include "core/CommandExecutor.h"
 #include "Timer.h"
-#include "core/CoreIncludes.h"
 namespace orxonox
+{
+    ConsoleCommandShortcutExtern(delay, AccessLevel::None);
+    /**
+        @brief Calls a console command after 'delay' seconds.
+        @param delay The delay in seconds
+        @param command The console command
+    */
+    void delay(float delay, const std::string& command)
+    {
+        StaticTimer *delaytimer = new StaticTimer();
+        ExecutorStatic* delayexecutor = createExecutor(createFunctor(&executeDelayedCommand));
+        delayexecutor->setDefaultValues(delaytimer, command);
+        delaytimer->setTimer(delay, false, delayexecutor);
+    }
+    /**
+        @brief Executes the command.
+        @param timer The timer to destroy after the command-execution
+        @param command The command to execute
+    */
+    void executeDelayedCommand(StaticTimer* timer, const std::string& command)
+    {
+        CommandExecutor::execute(command);
+        delete timer;
+    }
     /**
         @brief Constructor: Sets the default-values.
 …
         RegisterRootObject(TimerBase);
+        this->executor_ = 0;
         this->interval_ = 0;
         this->bLoop_ = false;
 …
         this->time_ = 0;
+    }
+    /**
+        @brief Deletes the executor.
+    */
+    TimerBase::~TimerBase()
+    {
+        delete this->executor_;
+    }
+    /**
+        @brief Executes the executor.
+    */
+    void TimerBase::run() const
+    {
+        (*this->executor_)();
+    }

code/trunk/src/orxonox/tools/Timer.h

-                      r1039
+                      r1052
     source.cc:
+        include "core/Executor.h"
         ClassName::ClassName()
+        {
             myTimer.setTimer(interval_in_seconds, bLoop, this, &ClassName::functionName);
+            myTimer.setTimer(interval_in_seconds, bLoop, this, createExecutor(createFunctor(&ClassName::functionName)));
+        }
 …
 #include "OrxonoxPrereqs.h"
+#include "core/CorePrereqs.h"
 #include "core/Tickable.h"
 namespace orxonox
+{
+    class StaticTimer;
+    void delay(float delay, const std::string& command);
+    void executeDelayedCommand(StaticTimer* timer, const std::string& command);
     //! TimerBase is the parent of the Timer class.
     class _OrxonoxExport TimerBase : public Tickable
+    {
         public:
             TimerBase();
+            ~TimerBase();
             virtual void run() const = 0;
+            void run() const;
             /** @brief Starts the Timer: Function-call after 'interval' seconds. */
+            inline void startTimer() { this->bActive_ = true; this->time_ = this->interval_; }
+            inline void startTimer()
+                { this->bActive_ = true; this->time_ = this->interval_; }
             /** @brief Stops the Timer. */
+            inline void stopTimer() { this->bActive_ = false; this->time_ = this->interval_; }
+            inline void stopTimer()
+                { this->bActive_ = false; this->time_ = this->interval_; }
             /** @brief Pauses the Timer - it will continue with the actual state if you unpause it. */
+            inline void pauseTimer() { this->bActive_ = false; }
+            inline void pauseTimer()
+                { this->bActive_ = false; }
             /** @brief Unpauses the Timer - continues with the given state. */
+            inline void unpauseTimer() { this->bActive_ = true; }
+            inline void unpauseTimer()
+                { this->bActive_ = true; }
             /** @brief Returns true if the Timer is active (= not stoped, not paused). @return True = Time is active */
+            inline bool isActive() const { return this->bActive_; }
+            inline bool isActive() const
+                { return this->bActive_; }
+            /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */
+            inline void addTime(float time)
+                { this->time_ += time; }
+            /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */
+            inline void removeTime(float time)
+                { this->time_ -= time; }
+            /** @brief Sets the interval of the Timer. @param interval The interval */
+            inline void setInterval(float interval)
+                { this->interval_ = interval; }
+            /** @brief Sets bLoop to a given value. @param bLoop True = loop */
+            inline void setLoop(bool bLoop)
+                { this->bLoop_ = bLoop; }
             void tick(float dt);
         protected:
+            float interval_;    //!< The time-interval in seconds
+            bool bLoop_;        //!< If true, the function gets called every 'interval' seconds
+            bool bActive_;      //!< If true, the Timer ticks and calls the function if the time's up
+            TimerBase();
+            float time_;        //!< Internal variable, counting the time till the next function-call
+            Executor* executor_; //!< The executor of the function that should be called when the time expires
+            float interval_;     //!< The time-interval in seconds
+            bool bLoop_;         //!< If true, the function gets called every 'interval' seconds
+            bool bActive_;       //!< If true, the Timer ticks and calls the function if the time's up
+            float time_;         //!< Internal variable, counting the time till the next function-call
     };
 …
+    {
         public:
+            /** @brief Constructor: Sets the default-values. */
+            Timer()
+            {
+                this->timerFunction_ = 0;
+                this->object_ = 0;
+            }
+            Timer() {}
             /**
 …
                 @param bLoop If true, the function gets called every 'interval' seconds
                 @param object The object owning the timer and the function
                 @param timerFunction A function pointer to the function to call
+                @param exeuctor A executor of the function to call
             */
             Timer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
+            Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor)
+            {
                 this->setTimer(interval, bLoop, timerFunction, object);
+                this->setTimer(interval, bLoop, object, exeuctor);
+            }
 …
                 @param bLoop If true, the function gets called every 'interval' seconds
                 @param object The object owning the timer and the function
                 @param timerFunction A function pointer to the function to call
+                @param exeuctor A executor of the function to call
             */
             void setTimer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
+            void setTimer(float interval, bool bLoop, T* object, ExecutorMember<T>* executor)
+            {
                 this->interval_ = interval;
                 this->bLoop_ = bLoop;
                 this->timerFunction_ = timerFunction;
                 this->object_ = object;
+                executor->setObject(object);
+                this->executor_ = (Executor*)executor;
                 this->bActive_ = true;
                 this->time_ = interval;
+            }
+    };
+            /** @brief Calls the given function of the given object. */
+            void run() const
+    //! The StaticTimer is a callback-object, calling a static function after a given time-interval.
+    class StaticTimer : public TimerBase
+    {
+        public:
+            StaticTimer() {}
+            /**
+                @brief Constructor: Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param exeuctor A executor of the function to call
+            */
+            StaticTimer(float interval, bool bLoop, ExecutorStatic* executor)
+            {
                 ((*this->object_).*timerFunction_)();
+                this->setTimer(interval, bLoop, executor);
+            }
+        private:
+            void (T::*timerFunction_)();
+            T* object_;
+            /**
+                @brief Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param executor A executor of the function to call
+            */
+            void setTimer(float interval, bool bLoop, ExecutorStatic* executor)
+            {
+                this->interval_ = interval;
+                this->bLoop_ = bLoop;
+                this->executor_ = (Executor*)executor;
+                this->bActive_ = true;
+                this->time_ = interval;
+            }
     };

code/trunk/src/util/CMakeLists.txt

r1051	r1052
8	8	Math.cc
9	9	String.cc
	10	Clipboard.cc
10	11	SubString.cc
11	12	MultiTypePrimitive.cc

code/trunk/src/util/Convert.h

-                      r871
+                      r1052
  *   Author:
  *      Benjamin Grauer
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      Fabian 'x3n' Landau
+ *      ...
  */
 …
+// DEFAULT CLASS
+template <typename FromType, typename ToType>
+class Converter
+{
+  public:
+    bool operator()(ToType* output, const FromType& input) const
+    {
+      return false;
+    }
+};
+// PARTIAL SPECIALIZATION TO CONVERT TO STRINGS
+template<typename FromType>
+class Converter<FromType, std::string>
+{
+  public:
+    bool operator()(std::string* output, const FromType& input) const
+    {
+      std::ostringstream oss;
+      if (oss << input)
+      {
+        (*output) = oss.str();
+//////////
+// MAIN //
+//////////
+// Enum to declare the wanted conversion preference in case of equal type-levels
+enum ConversionPreference
+{
+    CP_PreferToType,
+    CP_PreferFromType,
+};
+// Helper classes to determine the preferred partial template specialization
+class _ToType_   {};
+class _FromType_ {};
+class _Explicit_ {};
+// The default convert functions
+template <class FromType, class ToType, class Type>
+struct ConverterSpecialized
+{
+    enum { specialized = false };
+    static bool convert(ToType* output, const FromType& input)
+    { return false; }
+};
+// The default convert function if both types are the same
+template <class BothTypes>
+struct ConverterSpecialized<BothTypes, BothTypes, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(BothTypes* output, const BothTypes& input)
+    { (*output) = input; return true; }
+};
+// The possible levels
+#define __low__  0 // Everything that is or behaves like a primitive type (an can be converted with a typecast to every other low-level type)
+#define __mid__  1 // Everything that has overloaded << and >> operators to operate on a std::stream
+#define __high__ 2 // Everything that doesn't fullfill the lowerlevel-requirements and therefore needs specialized conversions
+// Defines the levels of all types: Default is __high__ so you don't have to define every high-level type
+template <class T> struct ConverterLevel           { enum { level = __high__ }; };
+template <> struct ConverterLevel<std::string>     { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Radian> { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Degree> { enum { level = __mid__ }; };
+template <> struct ConverterLevel<int>             { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned int>    { enum { level = __low__ }; };
+template <> struct ConverterLevel<char>            { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned char>   { enum { level = __low__ }; };
+template <> struct ConverterLevel<short>           { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned short>  { enum { level = __low__ }; };
+template <> struct ConverterLevel<long>            { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long>   { enum { level = __low__ }; };
+template <> struct ConverterLevel<float>           { enum { level = __low__ }; };
+template <> struct ConverterLevel<double>          { enum { level = __low__ }; };
+template <> struct ConverterLevel<long double>     { enum { level = __low__ }; };
+template <> struct ConverterLevel<bool>            { enum { level = __low__ }; };
+// Calculates the preference based on the levels of FromType and ToType
+template <int from, int to>
+struct ConverterPreference
+{
+    enum
+    {
+        // The maximum of both levels: element of {0, 1, 2}
+        // max 0: Both types are primitives or have a similar behaviour
+        // max 1: At least one type is not a primitive, but both can be put on a std::stream
+        // max 2: There is at least one generic type that needs specialized conversions
+        max = (from > to) ? from : to,
+        // The difference between both levels limited to +-1: element of {-1, 0, 1}
+        // diff -1: The FromType has higher level than the ToType
+        // diff  0: Both types have the same level
+        // diff  1: The ToType has higher level than the FromType
+        diff = ((to - from) > 1) ? 1 : (((to - from) < -1) ? -1 : to - from)
+    };
+};
+// The default conversion: This usually does nothing
+template <int max, class FromType, class ToType>
+struct ConverterDefault
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        return false;
+    }
+};
+// The default conversion for primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)    template <int max, class FromType, class ToType>
+template <class FromType, class ToType>
+struct ConverterDefault<0, FromType, ToType>
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        (*output) = (ToType)input;
         return true;
+      }
+      else
+        return false;
+    }
+};
+// PARTIAL SPECIALIZATION TO CONVERT FROM STRING
+template<typename ToType>
+class Converter<std::string, ToType>
+{
+  public:
+    bool operator()(ToType* output, const std::string& input) const
+    {
+      std::istringstream iss(input);
+      if (iss >> (*output))
+    }
+};
+// Converter: Converts input of FromType into output of ToType
+template <int diff, int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        return false;
+    }
+};
+// Converter: level{FromType} > level{ToType}
+template <int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter<-1, max, FromType, ToType, pref>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Converter: level{FromType} < level{ToType}
+template <int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter<1, max, FromType, ToType, pref>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Converter: level{FromType} = level{ToType}
+// CP_PreferToType
+template <int max, class FromType, class ToType>
+struct Converter<0, max, FromType, ToType, CP_PreferToType>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// CP_PreferFromType
+template <int max, class FromType, class ToType>
+struct Converter<0, max, FromType, ToType, CP_PreferFromType>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Calls the Converter::convertValue function with the correct template type parameters calculated by ConverterPreference
+template <class FromType, class ToType>
+static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType)
+{
+    return (preference == CP_PreferToType) ?
+           Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
+                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
+                     FromType,
+                     ToType,
+                     CP_PreferToType>::convert(output, input)
+         : Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
+                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
+                     FromType,
+                     ToType,
+                     CP_PreferFromType>::convert(output, input);
+}
+//////////////////////
+// HELPER FUNCTIONS //
+//////////////////////
+// Helper function: Calls convertValue with and without default value and returns true if the conversion was successful
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType)
+{
+    return convertValue(output, input, preference);
+}
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
+{
+    if (convertValue(output, input, preference))
         return true;
+      else
+        return false;
+    }
+};
+// FUNCTION SO WE DO NOT HAVE TO TELL THE COMPILER ABOUT THE TYPE
+template<typename FromType, typename ToType>
+static bool ConvertValue(ToType* output, const FromType& input)
+{
+  Converter<FromType, ToType> converter;
+  return converter(output, input);
+    (*output) = fallback;
+    return false;
+}
+// THE SAME, BUT WITH DEFAULT VALUE
+template<typename FromType, typename ToType>
+static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
+{
+  Converter<FromType, ToType> converter;
+  if (converter(output, input))
+    return true;
+  (*output) = fallback;
+  return false;
+// Helper function: Calls convertValue with and without default value and returns the converted value
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, ConversionPreference preference = CP_PreferToType)
+{
+    ToType output = ToType();
+    ConvertValue(&output, input, preference);
+    return output;
+}
+// THE SAME LIKE BEFORE, BUT NEEDS NO POINTER TO THE OUTPUT
+template<typename FromType, typename ToType>
+static ToType ConvertValueAndReturn(const FromType& input)
+{
+  ToType output;
+  ConvertValue(&output, input);
+  return output;
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
+{
+    ToType output = fallback;
+    ConvertValue(&output, input, fallback, preference);
+    return output;
+}
+// THE SAME, BUT WITH DEFAULT VALUE
+template<typename FromType, typename ToType>
+static ToType ConvertValueAndReturn(const FromType& input, const FromType& fallback)
+{
+  ToType output;
+  ConvertValue(&output, input, fallback);
+  return output;
+}
+//////////////////////////
+// MORE SPECIALISATIONS //
+//////////////////////////
+// STRING TO STRING
+template<>
+class Converter<std::string, std::string>
+{
+  public:
+    bool operator()(std::string* output, const std::string& input) const
+    {
+        (*output) = std::string(input);
+        return true;
+    }
+};
+/////////////////////
+// SPECIALIZATIONS //
+/////////////////////
+/////////////
+// SAMPLES //
+/////////////
+/*
+// convert everything to xyz
+template <class FromType>
+struct ConverterSpecialized<FromType, xyz, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(xyz* output, const FromType& input)
+    { return ...; }
+};
+// convert xyz to everything
+template <class ToType>
+struct ConverterSpecialized<xyz, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const xyz& input)
+    { return ...; }
+};
+// convert abc to xyz
+template <>
+struct ConverterSpecialized<abc, xyz, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(xyz* output, const abc& input)
+    { return ...; }
+};
+*/
+////////////
+// STRING //
+////////////
+// convert to string
+template <class FromType>
+struct ConverterSpecialized<FromType, std::string, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(std::string* output, const FromType& input)
+    {
+        std::ostringstream oss;
+        if (oss << input)
+        {
+            (*output) = oss.str();
+            return true;
+        }
+        else
+            return false;
+    }
+};
+// convert from string
+template <class ToType>
+struct ConverterSpecialized<std::string, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const std::string& input)
+    {
+        std::istringstream iss(input);
+        if (iss >> (*output))
+            return true;
+        else
+            return false;
+    }
+};
 ////////////////
 …
 ////////////////
+// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEPRIMITIVE
+template<typename ToType>
+class Converter<MultiTypePrimitive, ToType>
+{
+  public:
+    bool operator()(ToType* output, const MultiTypePrimitive& input) const
+    {
+      if (input.getType() == MT_int)
+        return ConvertValue(output, input.getInt());
+      else if (input.getType() == MT_uint)
+        return ConvertValue(output, input.getUnsignedInt());
+      else if (input.getType() == MT_char)
+        return ConvertValue(output, input.getChar());
+      else if (input.getType() == MT_uchar)
+        return ConvertValue(output, input.getUnsignedChar());
+      else if (input.getType() == MT_short)
+        return ConvertValue(output, input.getShort());
+      else if (input.getType() == MT_ushort)
+        return ConvertValue(output, input.getUnsignedShort());
+      else if (input.getType() == MT_long)
+        return ConvertValue(output, input.getLong());
+      else if (input.getType() == MT_ulong)
+        return ConvertValue(output, input.getUnsignedLong());
+      else if (input.getType() == MT_float)
+        return ConvertValue(output, input.getFloat());
+      else if (input.getType() == MT_double)
+        return ConvertValue(output, input.getDouble());
+      else if (input.getType() == MT_longdouble)
+        return ConvertValue(output, input.getLongDouble());
+      else if (input.getType() == MT_bool)
+        return ConvertValue(output, input.getBool());
+      else
+        return false;
+    }
+};
+template<>
+class Converter<MultiTypePrimitive, std::string>
+{
+  public:
+    bool operator()(std::string* output, const MultiTypePrimitive& input) const
+    {
+      if (input.getType() == MT_int)
+        return ConvertValue(output, input.getInt());
+      else if (input.getType() == MT_uint)
+        return ConvertValue(output, input.getUnsignedInt());
+      else if (input.getType() == MT_char)
+        return ConvertValue(output, input.getChar());
+      else if (input.getType() == MT_uchar)
+        return ConvertValue(output, input.getUnsignedChar());
+      else if (input.getType() == MT_short)
+        return ConvertValue(output, input.getShort());
+      else if (input.getType() == MT_ushort)
+        return ConvertValue(output, input.getUnsignedShort());
+      else if (input.getType() == MT_long)
+        return ConvertValue(output, input.getLong());
+      else if (input.getType() == MT_ulong)
+        return ConvertValue(output, input.getUnsignedLong());
+      else if (input.getType() == MT_float)
+        return ConvertValue(output, input.getFloat());
+      else if (input.getType() == MT_double)
+        return ConvertValue(output, input.getDouble());
+      else if (input.getType() == MT_longdouble)
+        return ConvertValue(output, input.getLongDouble());
+      else if (input.getType() == MT_bool)
+        return ConvertValue(output, input.getBool());
+      else
+        return false;
+    }
+};
+// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPESTRING
+template<typename ToType>
+class Converter<MultiTypeString, ToType>
+{
+  public:
+    bool operator()(ToType* output, const MultiTypeString& input) const
+    {
+      if (input.getType() == MT_constchar)
+        return ConvertValue(output, input.getConstChar());
+      else if (input.getType() == MT_string)
+        return ConvertValue(output, input.getString());
+      else
+        return ConvertValue(output, (MultiTypePrimitive)input);
+    }
+};
+template<>
+class Converter<MultiTypeString, std::string>
+{
+  public:
+    bool operator()(std::string* output, const MultiTypeString& input) const
+    {
+      if (input.getType() == MT_constchar)
+        return ConvertValue(output, input.getConstChar());
+      else if (input.getType() == MT_string)
+        return ConvertValue(output, input.getString());
+      else
+        return ConvertValue(output, (MultiTypePrimitive)input);
+    }
+};
+// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEMATH
+template<typename ToType>
+class Converter<MultiTypeMath, ToType>
+{
+  public:
+    bool operator()(ToType* output, const MultiTypeMath& input) const
+    {
+      if (input.getType() == MT_vector2)
+        return ConvertValue(output, input.getVector2());
+      else if (input.getType() == MT_vector3)
+        return ConvertValue(output, input.getVector3());
+      else if (input.getType() == MT_quaternion)
+        return ConvertValue(output, input.getQuaternion());
+      else if (input.getType() == MT_colourvalue)
+        return ConvertValue(output, input.getColourValue());
+      else if (input.getType() == MT_radian)
+        return ConvertValue(output, input.getRadian());
+      else if (input.getType() == MT_degree)
+        return ConvertValue(output, input.getDegree());
+      else
+        return ConvertValue(output, (MultiTypeString)input);
+    }
+};
+template<>
+class Converter<MultiTypeMath, std::string>
+{
+  public:
+    bool operator()(std::string* output, const MultiTypeMath& input) const
+    {
+      if (input.getType() == MT_vector2)
+        return ConvertValue(output, input.getVector2());
+      else if (input.getType() == MT_vector3)
+        return ConvertValue(output, input.getVector3());
+      else if (input.getType() == MT_quaternion)
+        return ConvertValue(output, input.getQuaternion());
+      else if (input.getType() == MT_colourvalue)
+        return ConvertValue(output, input.getColourValue());
+      else if (input.getType() == MT_radian)
+        return ConvertValue(output, input.getRadian());
+      else if (input.getType() == MT_degree)
+        return ConvertValue(output, input.getDegree());
+      else
+        return ConvertValue(output, (MultiTypeString)input);
+// convert from MultiTypePrimitive
+template <class ToType>
+struct ConverterSpecialized<MultiTypePrimitive, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypePrimitive& input)
+    {
+        if (input.getType() == MT_void)
+            return ConvertValue(output, input.getVoid());
+        else if (input.getType() == MT_int)
+            return ConvertValue(output, input.getInt());
+        else if (input.getType() == MT_uint)
+            return ConvertValue(output, input.getUnsignedInt());
+        else if (input.getType() == MT_char)
+            return ConvertValue(output, input.getChar());
+        else if (input.getType() == MT_uchar)
+            return ConvertValue(output, input.getUnsignedChar());
+        else if (input.getType() == MT_short)
+            return ConvertValue(output, input.getShort());
+        else if (input.getType() == MT_ushort)
+            return ConvertValue(output, input.getUnsignedShort());
+        else if (input.getType() == MT_long)
+            return ConvertValue(output, input.getLong());
+        else if (input.getType() == MT_ulong)
+            return ConvertValue(output, input.getUnsignedLong());
+        else if (input.getType() == MT_float)
+            return ConvertValue(output, input.getFloat());
+        else if (input.getType() == MT_double)
+            return ConvertValue(output, input.getDouble());
+        else if (input.getType() == MT_longdouble)
+            return ConvertValue(output, input.getLongDouble());
+        else if (input.getType() == MT_bool)
+            return ConvertValue(output, input.getBool());
+        else
+            return false;
+    }
+};
+// convert from MultiTypeString
+template <class ToType>
+struct ConverterSpecialized<MultiTypeString, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypeString& input)
+    {
+        if (input.getType() == MT_constchar)
+            return ConvertValue(output, input.getConstChar());
+        else if (input.getType() == MT_string)
+            return ConvertValue(output, input.getString());
+        else
+            return ConvertValue(output, (MultiTypePrimitive)input);
+    }
+};
+// convert from MultiTypeMath
+template <class ToType>
+struct ConverterSpecialized<MultiTypeMath, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypeMath& input)
+    {
+        if (input.getType() == MT_vector2)
+            return ConvertValue(output, input.getVector2());
+        else if (input.getType() == MT_vector3)
+            return ConvertValue(output, input.getVector3());
+        else if (input.getType() == MT_quaternion)
+            return ConvertValue(output, input.getQuaternion());
+        else if (input.getType() == MT_colourvalue)
+            return ConvertValue(output, input.getColourValue());
+        else if (input.getType() == MT_radian)
+            return ConvertValue(output, input.getRadian());
+        else if (input.getType() == MT_degree)
+            return ConvertValue(output, input.getDegree());
+        else
+            return ConvertValue(output, (MultiTypeString)input);
+    }
 };
 …
 // Vector2 to std::string
 template <>
+class Converter<orxonox::Vector2, std::string>
+{
+  public:
+    bool operator()(std::string* output, const orxonox::Vector2& input) const
+    {
+      std::ostringstream ostream;
+      if (ostream << input.x << "," << input.y)
+      {
+        (*output) = ostream.str();
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<orxonox::Vector2, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(std::string* output, const orxonox::Vector2& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.x << "," << input.y)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
 };
 …
 // Vector3 to std::string
 template <>
+class Converter<orxonox::Vector3, std::string>
+{
+  public:
+    bool operator()(std::string* output, const orxonox::Vector3& input) const
+    {
+      std::ostringstream ostream;
+      if (ostream << input.x << "," << input.y << "," << input.z)
+      {
+        (*output) = ostream.str();
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<orxonox::Vector3, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(std::string* output, const orxonox::Vector3& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.x << "," << input.y << "," << input.z)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
 };
 …
 // Vector4 to std::string
 template <>
+class Converter<orxonox::Vector4, std::string>
+{
+  public:
+    bool operator()(std::string* output, const orxonox::Vector4& input) const
+    {
+      std::ostringstream ostream;
+      if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+      {
+        (*output) = ostream.str();
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<orxonox::Vector4, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(std::string* output, const orxonox::Vector4& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
 };
 …
 // Quaternion to std::string
 template <>
+class Converter<orxonox::Quaternion, std::string>
+{
+  public:
+    bool operator()(std::string* output, const orxonox::Quaternion& input) const
+    {
+      std::ostringstream ostream;
+      if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+      {
+        (*output) = ostream.str();
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<orxonox::Quaternion, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(std::string* output, const orxonox::Quaternion& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
 };
 …
 // ColourValue to std::string
 template <>
+class Converter<orxonox::ColourValue, std::string>
+{
+  public:
+    bool operator()(std::string* output, const orxonox::ColourValue& input) const
+    {
+      std::ostringstream ostream;
+      if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+      {
+        (*output) = ostream.str();
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<orxonox::ColourValue, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(std::string* output, const orxonox::ColourValue& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
 };
 …
 // std::string to Vector2
 template <>
+class Converter<std::string, orxonox::Vector2>
+{
+  public:
+    bool operator()(orxonox::Vector2* output, const std::string& input) const
+    {
+      unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+      if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+      SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
+      if (tokens.size() >= 2)
+      {
+        if (!ConvertValue(&(output->x), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+          return false;
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<std::string, orxonox::Vector2, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Vector2* output, const std::string& input)
+    {
+        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 2)
+        {
+            if (!ConvertValue(&(output->x), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[1]))
+                return false;
+            return true;
+        }
+        return false;
+    }
 };
 …
 // std::string to Vector3
 template <>
+class Converter<std::string, orxonox::Vector3>
+{
+  public:
+    bool operator()(orxonox::Vector3* output, const std::string& input) const
+    {
+      unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+      if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+      SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
+      if (tokens.size() >= 3)
+      {
+        if (!ConvertValue(&(output->x), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+          return false;
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<std::string, orxonox::Vector3, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Vector3* output, const std::string& input)
+    {
+        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 3)
+        {
+            if (!ConvertValue(&(output->x), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->z), tokens[2]))
+                return false;
+            return true;
+        }
+        return false;
+    }
 };
 …
 // std::string to Vector4
 template <>
+class Converter<std::string, orxonox::Vector4>
+{
+  public:
+    bool operator()(orxonox::Vector4* output, const std::string& input) const
+    {
+      unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+      if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+      SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
+      if (tokens.size() >= 4)
+      {
+        if (!ConvertValue(&(output->x), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+          return false;
+        if (!ConvertValue(&(output->w), tokens[3]))
+          return false;
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<std::string, orxonox::Vector4, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Vector4* output, const std::string& input)
+    {
+        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 4)
+        {
+            if (!ConvertValue(&(output->x), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->z), tokens[2]))
+                return false;
+            if (!ConvertValue(&(output->w), tokens[3]))
+                return false;
+            return true;
+        }
+        return false;
+    }
 };
 …
 // std::string to Quaternion
 template <>
+class Converter<std::string, orxonox::Quaternion>
+{
+  public:
+    bool operator()(orxonox::Quaternion* output, const std::string& input) const
+    {
+      unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+      if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+      SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
+      if (tokens.size() >= 4)
+      {
+        if (!ConvertValue(&(output->w), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->x), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->y), tokens[2]))
+          return false;
+        if (!ConvertValue(&(output->z), tokens[3]))
+          return false;
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<std::string, orxonox::Quaternion, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Quaternion* output, const std::string& input)
+    {
+        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 4)
+        {
+            if (!ConvertValue(&(output->w), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->x), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[2]))
+                return false;
+            if (!ConvertValue(&(output->z), tokens[3]))
+                return false;
+            return true;
+        }
+        return false;
+    }
 };
 …
 // std::string to ColourValue
 template <>
+class Converter<std::string, orxonox::ColourValue>
+{
+  public:
+    bool operator()(orxonox::ColourValue* output, const std::string& input) const
+    {
+      unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+      if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+      SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', '"', '\0', '\0', '\0');
+      if (tokens.size() >= 4)
+      {
+        if (!ConvertValue(&(output->r), tokens[0]))
+          return false;
+        if (!ConvertValue(&(output->g), tokens[1]))
+          return false;
+        if (!ConvertValue(&(output->b), tokens[2]))
+          return false;
+        if (!ConvertValue(&(output->a), tokens[3]))
+          return false;
+        return true;
+      }
+      return false;
+struct ConverterSpecialized<std::string, orxonox::ColourValue, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::ColourValue* output, const std::string& input)
+    {
+        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 4)
+        {
+            if (!ConvertValue(&(output->r), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->g), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->b), tokens[2]))
+                return false;
+            if (!ConvertValue(&(output->a), tokens[3]))
+                return false;
+            return true;
+        }
+        return false;
+    }
 };

code/trunk/src/util/Math.h

-                      r892
+                      r1052
  */
 #ifndef _Math_H__
 #define _Math_H__
+#ifndef _Util_Math_H__
+#define _Util_Math_H__
 #include <ostream>
 …
+}
+#endif /* _Math_H__ */
+#endif /* _Util_Math_H__ */

code/trunk/src/util/MultiType.h

-                      r871
+                      r1052
+{
     MT_null,
+    MT_void,
     MT_int,
     MT_uint,
 …
     MT_constchar,
     MT_string,
+    MT_xmlelement,
     MT_vector2,
     MT_vector3,
 …
 union _UtilExport MultiTypeValue
+{
+    void*           void_;
     int             int_;
     unsigned int    uint_;

code/trunk/src/util/MultiTypeMath.cc

-                      r871
+                      r1052
+}
+MultiTypeMath::operator void*() const
+{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypeMath, void*>(*this, 0); }
 MultiTypeMath::operator int() const
 { return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypeMath, int>(*this); }
+{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypeMath, int>(*this, 0); }
 MultiTypeMath::operator unsigned int() const
 { return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypeMath, unsigned int>(*this); }
+{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypeMath, unsigned int>(*this, 0); }
 MultiTypeMath::operator char() const
 { return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypeMath, char>(*this); }
+{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypeMath, char>(*this, 0); }
 MultiTypeMath::operator unsigned char() const
 { return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypeMath, unsigned char>(*this); }
+{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypeMath, unsigned char>(*this, 0); }
 MultiTypeMath::operator short() const
 { return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypeMath, short>(*this); }
+{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypeMath, short>(*this, 0); }
 MultiTypeMath::operator unsigned short() const
 { return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypeMath, unsigned short>(*this); }
+{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypeMath, unsigned short>(*this, 0); }
 MultiTypeMath::operator long() const
 { return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypeMath, long>(*this); }
+{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypeMath, long>(*this, 0); }
 MultiTypeMath::operator unsigned long() const
 { return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypeMath, unsigned long>(*this); }
+{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypeMath, unsigned long>(*this, 0); }
 MultiTypeMath::operator float() const
 { return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypeMath, float>(*this); }
+{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypeMath, float>(*this, 0); }
 MultiTypeMath::operator double() const
 { return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypeMath, double>(*this); }
+{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypeMath, double>(*this, 0); }
 MultiTypeMath::operator long double() const
 { return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypeMath, long double>(*this); }
+{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypeMath, long double>(*this, 0); }
 MultiTypeMath::operator bool() const
 { return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypeMath, bool>(*this); }
+{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypeMath, bool>(*this, 0); }
 MultiTypeMath::operator std::string() const
 { return (this->type_ == MT_string) ? this->string_ : ConvertValueAndReturn<MultiTypeMath, std::string>(*this); }
+{ return (this->type_ == MT_string) ? this->string_ : getConvertedValue<MultiTypeMath, std::string>(*this); }
 MultiTypeMath::operator const char*() const
 { return ((this->type_ == MT_constchar) ? this->string_ : ConvertValueAndReturn<MultiTypeMath, std::string>(*this)).c_str(); }
+{ return ((this->type_ == MT_constchar) ? this->string_ : getConvertedValue<MultiTypeMath, std::string>(*this)).c_str(); }
 MultiTypeMath::operator orxonox::Vector2() const
 { return (this->type_ == MT_vector2) ? this->vector2_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Vector2>(*this); }
+{ return (this->type_ == MT_vector2) ? this->vector2_ : getConvertedValue<MultiTypeMath, orxonox::Vector2>(*this); }
 MultiTypeMath::operator orxonox::Vector3() const
 { return (this->type_ == MT_vector3) ? this->vector3_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Vector3>(*this); }
+{ return (this->type_ == MT_vector3) ? this->vector3_ : getConvertedValue<MultiTypeMath, orxonox::Vector3>(*this); }
 MultiTypeMath::operator orxonox::Quaternion() const
 { return (this->type_ == MT_quaternion) ? this->quaternion_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Quaternion>(*this); }
+{ return (this->type_ == MT_quaternion) ? this->quaternion_ : getConvertedValue<MultiTypeMath, orxonox::Quaternion>(*this); }
 MultiTypeMath::operator orxonox::ColourValue() const
 { return (this->type_ == MT_colourvalue) ? this->colourvalue_ : ConvertValueAndReturn<MultiTypeMath, orxonox::ColourValue>(*this); }
+{ return (this->type_ == MT_colourvalue) ? this->colourvalue_ : getConvertedValue<MultiTypeMath, orxonox::ColourValue>(*this); }
 MultiTypeMath::operator orxonox::Radian() const
 { return (this->type_ == MT_radian) ? this->radian_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Radian>(*this); }
+{ return (this->type_ == MT_radian) ? this->radian_ : getConvertedValue<MultiTypeMath, orxonox::Radian>(*this); }
 MultiTypeMath::operator orxonox::Degree() const
 { return (this->type_ == MT_degree) ? this->degree_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Degree>(*this); }
+{ return (this->type_ == MT_degree) ? this->degree_ : getConvertedValue<MultiTypeMath, orxonox::Degree>(*this); }
 void MultiTypeMath::setValue(const MultiTypeMath& mtm)
 …
     this->radian_ = mtm.radian_;
     this->degree_ = mtm.degree_;
+}
+std::string MultiTypeMath::getTypename() const
+{
+    if (this->type_ == MT_vector2)
+        return "Vector2";
+    else if (this->type_ == MT_vector3)
+        return "Vector3";
+    else if (this->type_ == MT_colourvalue)
+        return "ColourValue";
+    else if (this->type_ == MT_quaternion)
+        return "Quaternion";
+    else if (this->type_ == MT_radian)
+        return "Radian";
+    else if (this->type_ == MT_degree)
+        return "Degree";
+    else
+        return MultiTypeString::getTypename();
+}

code/trunk/src/util/MultiTypeMath.h

-                      r890
+                      r1052
+{
     public:
+        MultiTypeMath(MultiType      type = MT_null);
+        MultiTypeMath(MultiType type = MT_null);
+        inline MultiTypeMath(void*          value) : MultiTypeString(value) {}
         inline MultiTypeMath(int            value) : MultiTypeString(value) {}
         inline MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}
 …
         inline MultiTypeMath(long double    value) : MultiTypeString(value) {}
         inline MultiTypeMath(bool           value) : MultiTypeString(value) {}
         inline MultiTypeMath(const char*        value) : MultiTypeString(value) {}
         inline MultiTypeMath(const std::string& value) : MultiTypeString(value) {}
+        inline MultiTypeMath(const char*             value) : MultiTypeString(value) {}
+        inline MultiTypeMath(const std::string&      value) : MultiTypeString(value) {}
         inline MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
         inline MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
 …
         bool operator!=(const MultiTypeMath& mtm) const;
+        virtual operator void*()                const;
         virtual operator int()                  const;
         virtual operator unsigned int()         const;
 …
         inline void getValue(orxonox::Degree*      variable) const { (*variable) = orxonox::Degree      (this->degree_);      }
+        virtual std::string getTypename() const;
         virtual std::string toString() const;
         virtual bool fromString(const std::string value);

code/trunk/src/util/MultiTypePrimitive.cc

-                      r871
+                      r1052
     this->type_ = type;
+    if (type == MT_int)
+    if (type == MT_void)
+        this->value_.void_ = 0;
+    else if (type == MT_int)
         this->value_.int_ = 0;
     else if (type == MT_uint)
 …
         this->value_.bool_ = false;
     else
         this->value_.int_ = 0;
+        this->value_.void_ = 0;
+}
 …
     if (this->type_ == mtp.type_)
+    {
+        if (this->type_ == MT_int)
+        if (this->type_ == MT_void)
+            return (this->value_.void_ == mtp.value_.void_);
+        else if (this->type_ == MT_int)
             return (this->value_.int_ == mtp.value_.int_);
         else if (this->type_ == MT_uint)
 …
     if (this->type_ == mtp.type_)
+    {
+        if (this->type_ == MT_int)
+        if (this->type_ == MT_void)
+            return (this->value_.void_ != mtp.value_.void_);
+        else if (this->type_ == MT_int)
             return (this->value_.int_ != mtp.value_.int_);
         else if (this->type_ == MT_uint)
 …
+}
+MultiTypePrimitive::operator void*() const
+{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypePrimitive, void*>(*this, 0); }
 MultiTypePrimitive::operator int() const
 { return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypePrimitive, int>(*this); }
+{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypePrimitive, int>(*this, 0); }
 MultiTypePrimitive::operator unsigned int() const
 { return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned int>(*this); }
+{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypePrimitive, unsigned int>(*this, 0); }
 MultiTypePrimitive::operator char() const
 { return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypePrimitive, char>(*this); }
+{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypePrimitive, char>(*this, 0); }
 MultiTypePrimitive::operator unsigned char() const
 { return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned char>(*this); }
+{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypePrimitive, unsigned char>(*this, 0); }
 MultiTypePrimitive::operator short() const
 { return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypePrimitive, short>(*this); }
+{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypePrimitive, short>(*this, 0); }
 MultiTypePrimitive::operator unsigned short() const
 { return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned short>(*this); }
+{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypePrimitive, unsigned short>(*this, 0); }
 MultiTypePrimitive::operator long() const
 { return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypePrimitive, long>(*this); }
+{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypePrimitive, long>(*this, 0); }
 MultiTypePrimitive::operator unsigned long() const
 { return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned long>(*this); }
+{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypePrimitive, unsigned long>(*this, 0); }
 MultiTypePrimitive::operator float() const
 { return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypePrimitive, float>(*this); }
+{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypePrimitive, float>(*this, 0); }
 MultiTypePrimitive::operator double() const
 { return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypePrimitive, double>(*this); }
+{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypePrimitive, double>(*this, 0); }
 MultiTypePrimitive::operator long double() const
 { return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypePrimitive, long double>(*this); }
+{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypePrimitive, long double>(*this, 0); }
 MultiTypePrimitive::operator bool() const
 { return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypePrimitive, bool>(*this); }
+{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypePrimitive, bool>(*this, 0); }
 void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
 …
+}
+std::string MultiTypePrimitive::getTypename() const
+{
+    if (this->type_ == MT_void)
+        return "pointer";
+    else if (this->type_ == MT_int)
+        return "int";
+    else if (this->type_ == MT_uint)
+        return "unsigned int";
+    else if (this->type_ == MT_char)
+        return "char";
+    else if (this->type_ == MT_uchar)
+        return "unsigned char";
+    else if (this->type_ == MT_short)
+        return "short";
+    else if (this->type_ == MT_ushort)
+        return "unsigned short";
+    else if (this->type_ == MT_long)
+        return "long";
+    else if (this->type_ == MT_ulong)
+        return "unsigned long";
+    else if (this->type_ == MT_float)
+        return "float";
+    else if (this->type_ == MT_double)
+        return "double";
+    else if (this->type_ == MT_longdouble)
+        return "long double";
+    else if (this->type_ == MT_bool)
+        return "bool";
+    else
+        return "unknown";
+}
 std::string MultiTypePrimitive::toString() const
+{
     std::string output;
+    if (this->type_ == MT_int)
+    if (this->type_ == MT_void)
+        ConvertValue(&output, this->value_.void_);
+    else if (this->type_ == MT_int)
         ConvertValue(&output, this->value_.int_);
     else if (this->type_ == MT_uint)
 …
 bool MultiTypePrimitive::fromString(const std::string value)
+{
+    if (this->type_ == MT_int)
+    if (this->type_ == MT_void)
+        return ConvertValue(&this->value_.void_, value, (void*)0);
+    else if (this->type_ == MT_int)
         return ConvertValue(&this->value_.int_, value, (int)0);
     else if (this->type_ == MT_uint)

code/trunk/src/util/MultiTypePrimitive.h

-                      r890
+                      r1052
 #include "MultiType.h"
+namespace orxonox
+{
+    class BaseObject;
+}
 class _UtilExport MultiTypePrimitive
+{
     public:
+        MultiTypePrimitive(MultiType      type = MT_null);
+        MultiTypePrimitive(MultiType type = MT_null);
+        inline MultiTypePrimitive(void*          value) { this->setValue(value); }
         inline MultiTypePrimitive(int            value) { this->setValue(value); }
         inline MultiTypePrimitive(unsigned int   value) { this->setValue(value); }
 …
         inline MultiTypePrimitive& operator=(MultiType      value) { this->type_ = MT_null; return *this; }
+        inline MultiTypePrimitive& operator=(void*          value) { this->setValue(value); return *this; }
         inline MultiTypePrimitive& operator=(int            value) { this->setValue(value); return *this; }
         inline MultiTypePrimitive& operator=(unsigned int   value) { this->setValue(value); return *this; }
 …
         inline MultiTypePrimitive& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp); return *this; }
+        inline bool operator==(void*          value) const { return (this->value_.void_       == value); }
         inline bool operator==(int            value) const { return (this->value_.int_        == value); }
         inline bool operator==(unsigned int   value) const { return (this->value_.uint_       == value); }
 …
         bool operator==(const MultiTypePrimitive& mtp) const;
         inline bool operator!=(int            value) const { return (this->value_.int_        != value); }
+        inline bool operator!=(void*          value) const { return (this->value_.void_       != value); }
         inline bool operator!=(unsigned int   value) const { return (this->value_.uint_       != value); }
         inline bool operator!=(char           value) const { return (this->value_.char_       != value); }
 …
         bool operator!=(const MultiTypePrimitive& mtp) const;
+        template <class T>
+        operator T*()                     const
+        { return ((T*)this->value_.void_); }
+        virtual operator void*()          const;
         virtual operator int()            const;
         virtual operator unsigned int()   const;
 …
         virtual operator bool()           const;
+        inline void setValue(void*          value) { this->type_ = MT_void;       this->value_.void_       = value; }
         inline void setValue(int            value) { this->type_ = MT_int;        this->value_.int_        = value; }
         inline void setValue(unsigned int   value) { this->type_ = MT_uint;       this->value_.uint_       = value; }
 …
         void setValue(const MultiTypePrimitive& mtp);
+        inline void*          getVoid()          const { return this->value_.void_;        }
         inline int            getInt()           const { return this->value_.int_;        }
         inline unsigned int   getUnsignedInt()   const { return this->value_.uint_;       }
 …
         inline bool&           getBool()          { return this->value_.bool_;       }
+        inline void getValue(void*           variable) const { variable    = this->value_.void_;       }
         inline void getValue(int*            variable) const { (*variable) = this->value_.int_;        }
         inline void getValue(unsigned int*   variable) const { (*variable) = this->value_.uint_;       }
 …
         inline bool      isA(MultiType type) const { return (this->type_ == type); }
+        virtual std::string getTypename() const;
         virtual std::string toString() const;
         virtual bool fromString(const std::string value);

code/trunk/src/util/MultiTypeString.cc

-                      r871
+                      r1052
 MultiTypeString::MultiTypeString(MultiType type) : MultiTypePrimitive(type)
+{
+    if (type == MT_constchar)
+        this->string_ = std::string("");
+    else if (type == MT_string)
+        this->string_ = std::string("");
+    // Nothing to do for string and xml-element
+}
 …
+}
+MultiTypeString::operator void*() const
+{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypeString, void*>(*this, 0); }
 MultiTypeString::operator int() const
 { return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypeString, int>(*this); }
+{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypeString, int>(*this, 0); }
 MultiTypeString::operator unsigned int() const
 { return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypeString, unsigned int>(*this); }
+{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypeString, unsigned int>(*this, 0); }
 MultiTypeString::operator char() const
 { return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypeString, char>(*this); }
+{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypeString, char>(*this, 0); }
 MultiTypeString::operator unsigned char() const
 { return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypeString, unsigned char>(*this); }
+{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypeString, unsigned char>(*this, 0); }
 MultiTypeString::operator short() const
 { return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypeString, short>(*this); }
+{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypeString, short>(*this, 0); }
 MultiTypeString::operator unsigned short() const
 { return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypeString, unsigned short>(*this); }
+{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypeString, unsigned short>(*this, 0); }
 MultiTypeString::operator long() const
 { return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypeString, long>(*this); }
+{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypeString, long>(*this, 0); }
 MultiTypeString::operator unsigned long() const
 { return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypeString, unsigned long>(*this); }
+{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypeString, unsigned long>(*this, 0); }
 MultiTypeString::operator float() const
 { return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypeString, float>(*this); }
+{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypeString, float>(*this, 0); }
 MultiTypeString::operator double() const
 { return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypeString, double>(*this); }
+{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypeString, double>(*this, 0); }
 MultiTypeString::operator long double() const
 { return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypeString, long double>(*this); }
+{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypeString, long double>(*this, 0); }
 MultiTypeString::operator bool() const
 { return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypeString, bool>(*this); }
+{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypeString, bool>(*this, 0); }
 MultiTypeString::operator std::string() const
 { return (this->type_ == MT_string) ? this->string_ : ConvertValueAndReturn<MultiTypeString, std::string>(*this); }
+{ return (this->type_ == MT_string) ? this->string_ : getConvertedValue<MultiTypeString, std::string>(*this); }
 MultiTypeString::operator const char*() const
 { return ((this->type_ == MT_constchar) ? this->string_ : ConvertValueAndReturn<MultiTypeString, std::string>(*this)).c_str(); }
+{ return ((this->type_ == MT_constchar) ? this->string_ : getConvertedValue<MultiTypeString, std::string>(*this)).c_str(); }
 void MultiTypeString::setValue(const MultiTypeString& mts)
 …
+}
+std::string MultiTypeString::getTypename() const
+{
+    if (this->type_ == MT_constchar)
+        return "string";
+    else if (this->type_ == MT_string)
+        return "string";
+    else
+        return MultiTypePrimitive::getTypename();
+}
 std::string MultiTypeString::toString() const
+{
+    std::string output;
     if (this->type_ == MT_constchar)
         return this->string_;
 …
     else
         return MultiTypePrimitive::toString();
+    return output;
+}

code/trunk/src/util/MultiTypeString.h

-                      r890
+                      r1052
+{
     public:
+        MultiTypeString(MultiType      type = MT_null);
+        MultiTypeString(MultiType type = MT_null);
+        inline MultiTypeString(void*          value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(int            value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(unsigned int   value) : MultiTypePrimitive(value) {}
 …
         inline MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(const char*        value)   { this->setValue(value); }
         inline MultiTypeString(const std::string& value)   { this->setValue(value); }
         inline MultiTypeString(const MultiTypeString& mts) { this->setValue(mts);   }
+        inline MultiTypeString(const char*           value)   { this->setValue(value); }
+        inline MultiTypeString(const std::string&    value)   { this->setValue(value); }
+        inline MultiTypeString(const MultiTypeString& mts)    { this->setValue(mts);   }
         virtual inline ~MultiTypeString() {}
         using MultiTypePrimitive::operator=;
         inline MultiTypeString& operator=(const char*        value)   { this->setValue(value); return *this; }
         inline MultiTypeString& operator=(const std::string& value)   { this->setValue(value); return *this; }
         inline MultiTypeString& operator=(const MultiTypeString& mts) { this->setValue(mts);   return *this; }
+        inline MultiTypeString& operator=(const char*             value)   { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const std::string&      value)   { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const MultiTypeString& mts)      { this->setValue(mts);   return *this; }
         using MultiTypePrimitive::operator==;
         inline bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
         inline bool operator==(const std::string& value) const { return (this->string_ == value);              }
+        inline bool operator==(const char*             value) const { return (this->string_      == std::string(value)); }
+        inline bool operator==(const std::string&      value) const { return (this->string_      == value);              }
         bool operator==(const MultiTypeString& mts) const;
         using MultiTypePrimitive::operator!=;
         inline bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
         inline bool operator!=(const std::string& value) const { return (this->string_ != value);              }
+        inline bool operator!=(const char*             value) const { return (this->string_      != std::string(value)); }
+        inline bool operator!=(const std::string&      value) const { return (this->string_      != value);              }
         bool operator!=(const MultiTypeString& mts) const;
+        virtual operator int()            const;
+        virtual operator unsigned int()   const;
+        virtual operator char()           const;
+        virtual operator unsigned char()  const;
+        virtual operator short()          const;
+        virtual operator unsigned short() const;
+        virtual operator long()           const;
+        virtual operator unsigned long()  const;
+        virtual operator float ()         const;
+        virtual operator double ()        const;
+        virtual operator long double()    const;
+        virtual operator bool()           const;
+        virtual operator std::string()    const;
+        virtual operator const char*()    const;
+        virtual operator void*()                const;
+        virtual operator int()                  const;
+        virtual operator unsigned int()         const;
+        virtual operator char()                 const;
+        virtual operator unsigned char()        const;
+        virtual operator short()                const;
+        virtual operator unsigned short()       const;
+        virtual operator long()                 const;
+        virtual operator unsigned long()        const;
+        virtual operator float ()               const;
+        virtual operator double ()              const;
+        virtual operator long double()          const;
+        virtual operator bool()                 const;
+        virtual operator std::string()          const;
+        virtual operator const char*()          const;
         using MultiTypePrimitive::setValue;
         inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }
         inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value;              }
+        inline void setValue(const char*             value) { this->type_ = MT_string;     this->string_     = std::string(value); }
+        inline void setValue(const std::string&      value) { this->type_ = MT_string;     this->string_     = value;              }
         void setValue(const MultiTypeString& mts);
         inline const std::string getString() const { return this->string_;         }
         inline const char*  getConstChar()   const { return this->string_.c_str(); }
+        inline std::string getString()          const { return this->string_;         }
+        inline const char*  getConstChar()      const { return this->string_.c_str(); }
         inline const std::string& getString() { return this->string_;         }
         inline const char*  getConstChar()    { return this->string_.c_str(); }
+        inline std::string& getString()          { return this->string_;         }
+        inline const char*  getConstChar()       { return this->string_.c_str(); }
         using MultiTypePrimitive::getValue;
+        inline void getValue(std::string* variable) const { (*variable) = this->string_;         }
+        inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }
+        inline void getValue(std::string*      variable) const { (*variable) = this->string_;         }
+        inline void getValue(const char**      variable) const { (*variable) = this->string_.c_str(); }
+        virtual std::string getTypename() const;
         virtual std::string toString() const;
 …
     protected:
         std::string string_;
+        std::string      string_;
 };

code/trunk/src/util/String.cc

-                      r871
+                      r1052
  */
+#include <cctype>
+#include <iostream>
 #include "String.h"
 …
 /**
+    @brief Returns a copy of a string without trailing whitespaces.
+    @param str The string
+    @return The modified copy
+*/
+std::string removeTrailingWhitespaces(const std::string& str)
+{
+    unsigned int pos1 = 0;
+    unsigned int pos2 = str.size() - 1;
+    for (; pos1 < str.size() && (str[pos1] == ' ' || str[pos1] == '\t' || str[pos1] == '\n'); pos1++);
+    for (; pos2 >= 0         && (str[pos2] == ' ' || str[pos2] == '\t' || str[pos2] == '\n'); pos2--);
+    return str.substr(pos1, pos2 - pos1 + 1);
+}
+/**
+    @brief Returns the position of the next quote in the string, starting with start.
+    @param str The string
+    @param start The startposition
+    @return The position of the next quote (std::string::npos if there is no next quote)
+*/
+unsigned int getNextQuote(const std::string& str, unsigned int start)
+{
+    unsigned int quote = start - 1;
+    while ((quote = str.find('\"', quote + 1)) != std::string::npos)
+    {
+        unsigned int backslash = quote;
+        unsigned int numbackslashes = 0;
+        for (; backslash > 0; backslash--, numbackslashes++)
+            if (str[backslash - 1] != '\\')
+                break;
+        if (numbackslashes % 2 == 0)
+            break;
+    }
+    return quote;
+}
+/**
+    @brief Returns true if pos is between two quotes.
+    @param str The string
+    @param pos The position to check
+    @return True if pos is between two quotes
+*/
+bool isBetweenQuotes(const std::string& str, unsigned int pos)
+{
+    if (pos == std::string::npos)
+        return false;
+    unsigned int quotecount = 0;
+    unsigned int quote = 0;
+    while ((quote = getNextQuote(str, quote)) < pos)
+    {
+        quotecount++;
+    }
+    if (quote == std::string::npos)
+        return false;
+    return ((quotecount % 2) == 1);
+}
+/**
+    @brief Returns true if the string contains something like '..."between quotes"...'
+    @param The string
+    @return True if there is something between quotes
+*/
+bool hasStringBetweenQuotes(const std::string& str)
+{
+    unsigned int pos1 = getNextQuote(str, 0);
+    unsigned int pos2 = getNextQuote(str, pos1 + 1);
+    return (pos1 != std::string::npos && pos2 != std::string::npos && pos2 > pos1 + 1);
+}
+/**
+    @brief If the string contains something like '..."between quotes"...' then 'between quotes' gets returned (without quotes).
+    @param The string
+    @param The string between the quotes
+*/
+std::string getStringBetweenQuotes(const std::string& str)
+{
+    unsigned int pos1 = getNextQuote(str, 0);
+    unsigned int pos2 = getNextQuote(str, pos1 + 1);
+    if (pos1 != std::string::npos && pos2 != std::string::npos)
+        return str.substr(pos1, pos2 - pos1 + 1);
+    else
+        return "";
+}
+/**
+    @brief Removes enclosing quotes if available.
+    @brief str The string to strip
+    @return The string with removed quotes
+*/
+std::string stripEnclosingQuotes(const std::string& str)
+{
+    unsigned int start = std::string::npos;
+    unsigned int end = 0;
+    for (unsigned int pos = 0; (pos < str.size()) && (pos < std::string::npos); pos++)
+    {
+        if (str[pos] == '"')
+        {
+            start = pos;
+            break;
+        }
+        if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
+            return str;
+    }
+    for (unsigned int pos = str.size() - 1; pos < std::string::npos; pos--)
+    {
+        if (str[pos] == '"')
+        {
+            end = pos;
+            break;
+        }
+        if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
+            return str;
+    }
+    if ((start != std::string::npos) && (end != 0))
+        return str.substr(start + 1, end - start - 1);
+    else
+        return str;
+}
+/**
     @brief Determines if a string in is a comment.
     @param str The string to check
 …
     //  3) ;comment in unreal tournament config-file style
     //  4) //comment in code style
+    if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[0] == '/'))
+        return true;
+    if (teststring.size() >= 2)
+    {
+        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[1] == '/'))
+            return true;
+    }
+    else if (teststring.size() == 1)
+    {
+        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';')
+            return true;
+    }
     return false;
 …
 bool isEmpty(const std::string& str)
+{
+    return getStripped(str) == "";
+    std::string temp = getStripped(str);
+    return ((temp == "") || (temp.size() == 0));
+}
 …
+}
+std::string addSlashes(const std::string& str)
+{
+    std::string output = str;
+    for (unsigned int pos = 0; (pos = output.find('\\', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\\"); }
+    for (unsigned int pos = 0; (pos = output.find('\n', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\n"); }
+    for (unsigned int pos = 0; (pos = output.find('\t', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\t"); }
+    for (unsigned int pos = 0; (pos = output.find('\v', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\v"); }
+    for (unsigned int pos = 0; (pos = output.find('\b', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\b"); }
+    for (unsigned int pos = 0; (pos = output.find('\r', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\r"); }
+    for (unsigned int pos = 0; (pos = output.find('\f', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\f"); }
+    for (unsigned int pos = 0; (pos = output.find('\a', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\a"); }
+    for (unsigned int pos = 0; (pos = output.find('"', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\""); }
+    for (unsigned int pos = 0; (pos = output.find('\0', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\0"); }
+    return output;
+}
+std::string removeSlashes(const std::string& str)
+{
+    if (str.size() == 0)
+        return str;
+    std::string output = "";
+    for (unsigned int pos = 0; pos < str.size() - 1; )
+    {
+        if (str[pos] == '\\')
+        {
+            if (str[pos + 1] == '\\') { output += '\\'; pos += 2; continue; }
+            else if (str[pos + 1] == 'n') { output += '\n'; pos += 2; continue; }
+            else if (str[pos + 1] == 't') { output += '\t'; pos += 2; continue; }
+            else if (str[pos + 1] == 'v') { output += '\v'; pos += 2; continue; }
+            else if (str[pos + 1] == 'b') { output += '\b'; pos += 2; continue; }
+            else if (str[pos + 1] == 'r') { output += '\r'; pos += 2; continue; }
+            else if (str[pos + 1] == 'f') { output += '\f'; pos += 2; continue; }
+            else if (str[pos + 1] == 'a') { output += '\a'; pos += 2; continue; }
+            else if (str[pos + 1] == '"') { output += '"'; pos += 2; continue; }
+            else if (str[pos + 1] == '0') { output += '\0'; pos += 2; continue; }
+        }
+        output += str[pos];
+        pos++;
+        if (pos == str.size() - 1)
+            output += str[pos];
+    }
+    return output;
+}
 /**
     @brief Replaces each char between A and Z with its lowercase equivalent.
 …
 void lowercase(std::string* str)
+{
+    static unsigned const char difference_between_A_and_a = 'A' - 'a';
+    for (std::string::iterator it = (*str).begin(); it != (*str).end(); ++it)
+        if ((*it) >= 'A' && (*it) <= 'Z')
+            (*it) -= difference_between_A_and_a;
+    for (unsigned int i = 0; i < str->size(); ++i)
+    {
+        (*str)[i] = tolower((*str)[i]);
+    }
+}
 …
 void uppercase(std::string* str)
+{
+    static unsigned const char difference_between_A_and_a = 'A' - 'a';
+    for (std::string::iterator it = (*str).begin(); it != (*str).end(); ++it)
+        if ((*it) >= 'a' && (*it) <= 'z')
+            (*it) += difference_between_A_and_a;
+    for (unsigned int i = 0; i < str->size(); ++i)
+    {
+        (*str)[i] = toupper((*str)[i]);
+    }
+}
 …
 /**
  * @brief compares two strings without ignoring the case
  * @param s1 first string
  * @param s2 second string
  */
+    @brief compares two strings without ignoring the case
+    @param s1 first string
+    @param s2 second string
+*/
 int nocaseCmp(const std::string& s1, const std::string& s2)
+{
 …
 /**
  * @brief compares two strings without ignoring the case
  * @param s1 first string
  * @param s2 second string
  * @param len how far from the beginning to start.
  */
+    @brief compares two strings without ignoring the case
+    @param s1 first string
+    @param s2 second string
+    @param len how far from the beginning to start.
+*/
 int nocaseCmp(const std::string& s1, const std::string& s2, unsigned int len)
+{
 …
     return 0;
+}
+/**
+    @brief Returns true if the string contains a comment, introduced by #, %, ; or //.
+    @param str The string
+    @return True if the string contains a comment
+*/
+bool hasComment(const std::string& str)
+{
+    return (getCommentPosition(str) != std::string::npos);
+}
+/**
+    @brief If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
+    @param str The string
+    @return The comment
+*/
+std::string getComment(const std::string& str)
+{
+    return str.substr(getCommentPosition(str));
+}
+/**
+    @brief If the string contains a comment, the position of the comment-symbol gets returned, std::string::npos otherwise.
+    @param str The string
+    @return The position
+*/
+unsigned int getCommentPosition(const std::string& str)
+{
+    return getNextCommentPosition(str, 0);
+}
+/**
+    @brief Returns the position of the next comment-symbol, starting with start.
+    @param str The string
+    @param start The startposition
+    @return The position
+*/
+unsigned int getNextCommentPosition(const std::string& str, unsigned int start)
+{
+    for (unsigned int i = start; i < str.size(); i++)
+        if (isComment(str.substr(i)))
+            return i;
+    return std::string::npos;
+}

code/trunk/src/util/String.h

-                      r871
+                      r1052
  */
 #ifndef _String_H__
 #define _String_H__
+#ifndef _Util_String_H__
+#define _Util_String_H__
 #include <string>
 …
 #include "UtilPrereqs.h"
 _UtilExport void        strip(std::string* str);
 _UtilExport std::string getStripped(const std::string& str);
+_UtilExport void         strip(std::string* str);
+_UtilExport std::string  getStripped(const std::string& str);
+_UtilExport bool        isEmpty(const std::string& str);
+_UtilExport bool        isComment(const std::string& str);
+_UtilExport bool        isNumeric(const std::string& str);
+_UtilExport std::string  removeTrailingWhitespaces(const std::string& str);
 _UtilExport void        lowercase(std::string* str);
 _UtilExport std::string getLowercase(const std::string& str);
+_UtilExport unsigned int getNextQuote(const std::string& str, unsigned int start);
+_UtilExport bool         isBetweenQuotes(const std::string& str, unsigned int pos);
 _UtilExport void        uppercase(std::string* str);
 _UtilExport std::string getUppercase(const std::string& str);
+_UtilExport bool         hasStringBetweenQuotes(const std::string& str);
+_UtilExport std::string  getStringBetweenQuotes(const std::string& str);
+_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2);
+_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2, unsigned int len);
+_UtilExport std::string  stripEnclosingQuotes(const std::string& str);
+_UtilExport bool         isEmpty(const std::string& str);
+_UtilExport bool         isComment(const std::string& str);
+_UtilExport bool         isNumeric(const std::string& str);
+_UtilExport std::string  addSlashes(const std::string& str);
+_UtilExport std::string  removeSlashes(const std::string& str);
+_UtilExport void         lowercase(std::string* str);
+_UtilExport std::string  getLowercase(const std::string& str);
+_UtilExport void         uppercase(std::string* str);
+_UtilExport std::string  getUppercase(const std::string& str);
+_UtilExport int          nocaseCmp(const std::string& s1, const std::string& s2);
+_UtilExport int          nocaseCmp(const std::string& s1, const std::string& s2, unsigned int len);
+_UtilExport bool         hasComment(const std::string& str);
+_UtilExport std::string  getComment(const std::string& str);
+_UtilExport unsigned int getCommentPosition(const std::string& str);
+_UtilExport unsigned int getNextCommentPosition(const std::string& str, unsigned int start = 0);
 //! The Convert class has some static member functions to convert strings to values and values to strings.
 …
 };
 #endif /* _String_H__ */
+#endif /* _Util_String_H__ */

code/trunk/src/util/SubString.cc

-                      r871
+                      r1052
 SubString::SubString(const std::string& string,
                      const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                     char escapeChar, char safemode_char, char openparenthesis_char, char closeparenthesis_char, char comment_char)
+{
+  SubString::splitLine(this->strings, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, safemode_char, openparenthesis_char, closeparenthesis_char, comment_char);
+                     char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
+                     char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+{
+  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
+}
 …
+{
   for (unsigned int i = subSetBegin; i < subString.size(); i++)
+  {
     this->strings.push_back(subString[i]);
+    this->bInSafemode.push_back(subString.isInSafemode(i));
+  }
+}
 …
 SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
+{
+  for (unsigned int i = subSetBegin; i < subString.size() || i < subSetEnd; i++)
+  for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
+  {
     this->strings.push_back(subString[i]);
+    this->bInSafemode.push_back(subString.isInSafemode(i));
+  }
+}
 …
+{
   for(unsigned int i = 0; i < argc; ++i)
+  {
     this->strings.push_back(std::string(argv[i]));
+    this->bInSafemode.push_back(false);
+  }
+}
 …
+{
   this->strings = subString.strings;
+  this->bInSafemode = subString.bInSafemode;
   return *this;
+}
 …
 bool SubString::operator==(const SubString& subString) const
+{
   return (this->strings == subString.strings);
+  return ((this->strings == subString.strings) && (this->bInSafemode == subString.bInSafemode));
+}
 …
   for (unsigned int i = 0; i < length; i++)
     if (this->strings[i] != subString.strings[i])
+    if ((this->strings[i] != subString.strings[i]) || (this->bInSafemode[i] != subString.bInSafemode[i]))
       return false;
   return true;
 …
+{
   for (unsigned int i = 0; i < subString.size(); i++)
+  {
     this->strings.push_back(subString[i]);
+    this->bInSafemode.push_back(subString.isInSafemode(i));
+  }
   return *this;
+}
 …
+{
   this->strings.clear();
+  this->bInSafemode.clear();
   char split[2];
   split[0] = splitter;
   split[1] = '\0';
   SubString::splitLine(this->strings, string, split);
+  SubString::splitLine(this->strings, this->bInSafemode, string, split);
   return strings.size();
+}
 …
 unsigned int SubString::split(const std::string& string,
                               const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                              char escapeChar, char safemode_char, char openparenthesis_char, char closeparenthesis_char, char comment_char)
+                              char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
+                              char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+{
   this->strings.clear();
+  SubString::splitLine(this->strings, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, safemode_char, openparenthesis_char, closeparenthesis_char, comment_char);
+  this->bInSafemode.clear();
+  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
   return this->strings.size();
+}
 …
  * @param escape_char: Escape carater (escapes splitters)
  * @param safemode_char: the beginning of the safemode is marked with this
+ * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
+ * @param openparenthesis_char the beginning of a safemode is marked with this
+ * @param closeparenthesis_char the ending of a safemode is marked with this
+ * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
  * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
  * @param start_state: the Initial state on how to parse the String.
  * @returns SPLIT_LINE_STATE the parser was in when returning
+ * @return SPLIT_LINE_STATE the parser was in when returning
+ *
  * This is the Actual Splitting Algorithm from Clemens Wacha
 …
 SubString::SPLIT_LINE_STATE
 SubString::splitLine(std::vector<std::string>& ret,
+                     std::vector<bool>& bInSafemode,
                      const std::string& line,
                      const std::string& delimiters,
 …
                      bool emptyEntries,
                      char escape_char,
+                     bool removeExcapeChar,
                      char safemode_char,
+                     bool removeSafemodeChar,
                      char openparenthesis_char,
                      char closeparenthesis_char,
+                     bool removeParenthesisChars,
                      char comment_char,
                      SPLIT_LINE_STATE start_state)
 …
   std::string token;
+  bool inSafemode = false;
   if(start_state != SL_NORMAL && ret.size() > 0)
 …
     token = ret[ret.size()-1];
     ret.pop_back();
+  }
+  if(start_state != SL_NORMAL && bInSafemode.size() > 0)
+  {
+    inSafemode = bInSafemode[bInSafemode.size()-1];
+    bInSafemode.pop_back();
+  }
 …
+        {
           state = SL_ESCAPE;
+          if (!removeExcapeChar)
+            token += line[i];
+        }
         else if(line[i] == safemode_char)
+        {
           state = SL_SAFEMODE;
+          inSafemode = true;
+          if (!removeSafemodeChar)
+            token += line[i];
+        }
         else if(line[i] == openparenthesis_char)
+        {
           state = SL_PARENTHESES;
+          inSafemode = true;
+          if (!removeParenthesisChars)
+            token += line[i];
+        }
         else if(line[i] == comment_char)
 …
             ret.push_back(token);
             token.clear();
+            bInSafemode.push_back(inSafemode);
+            inSafemode = false;
+          }
           token += line[i];       // EAT
 …
             ret.push_back(token);
             token.clear();
+            bInSafemode.push_back(inSafemode);
+            inSafemode = false;
+          }
           state = SL_NORMAL;
 …
         break;
       case SL_ESCAPE:
+        if(line[i] == 'n') token += '\n';
+        else if(line[i] == 't') token += '\t';
+        else if(line[i] == 'v') token += '\v';
+        else if(line[i] == 'b') token += '\b';
+        else if(line[i] == 'r') token += '\r';
+        else if(line[i] == 'f') token += '\f';
+        else if(line[i] == 'a') token += '\a';
+        else if(line[i] == '?') token += '\?';
+        else token += line[i];  // EAT
+        if (!removeSafemodeChar)
+          token += line[i];
+        else
+        {
+          if(line[i] == 'n') token += '\n';
+          else if(line[i] == 't') token += '\t';
+          else if(line[i] == 'v') token += '\v';
+          else if(line[i] == 'b') token += '\b';
+          else if(line[i] == 'r') token += '\r';
+          else if(line[i] == 'f') token += '\f';
+          else if(line[i] == 'a') token += '\a';
+          else if(line[i] == '?') token += '\?';
+          else token += line[i];  // EAT
+        }
         state = SL_NORMAL;
         break;
 …
+        {
           state = SL_NORMAL;
+          if (!removeSafemodeChar)
+            token += line[i];
+        }
         else if(line[i] == escape_char)
 …
+        {
           state = SL_NORMAL;
+          if (!removeParenthesisChars)
+            token += line[i];
+        }
         else if(line[i] == escape_char)
 …
             ret.push_back(token);
             token.clear();
+            bInSafemode.push_back(inSafemode);
+            inSafemode = false;
+          }
           state = SL_NORMAL;
 …
     ret.push_back(token);
     token.clear();
+    bInSafemode.push_back(inSafemode);
+    inSafemode = false;
+  }
   return(state);

code/trunk/src/util/SubString.h

-                      r871
+                      r1052
   SubString(const std::string& string,
             const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
+            char escapeChar ='\\', char safemode_char = '"', char openparenthesis_char = '(', char closeparenthesis_char = ')', char comment_char = '\0');
+            char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
+            char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
   SubString(unsigned int argc, const char** argv);
   /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
 …
   unsigned int split(const std::string& string,
                      const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
+                     char escapeChar ='\\', char safemode_char = '"', char openparenthesis_char = '(', char closeparenthesis_char = ')', char comment_char = '\0');
+                     char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
+                     char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
   std::string join(const std::string& delimiter = " ") const;
   ////////////////////////////////////////
 …
   // retrieve Information from within
   /** @returns true if the SubString is empty */
+  /** @brief Returns true if the SubString is empty */
   inline bool empty() const { return this->strings.empty(); };
   /** @returns the count of Strings stored in this substring */
+  /** @brief Returns the count of Strings stored in this substring */
   inline unsigned int size() const { return this->strings.size(); };
   /** @param i the i'th String @returns the i'th string from the subset of Strings */
+  /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
   inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
   /** @param i the i'th String @returns the i'th string from the subset of Strings */
+  /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
   inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
+  /** @returns the front of the StringList. */
+  /** @brief Returns true if the token is in safemode. @param i the i'th token */
+  inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
+  /** @brief Returns the front of the StringList. */
   inline const std::string& front() const { return this->strings.front(); };
   /** @returns the back of the StringList. */
+  /** @brief Returns the back of the StringList. */
   inline const std::string& back() const { return this->strings.back(); };
   /** @brief removes the back of the strings list. */
   inline void pop_back() { this->strings.pop_back(); };
+  inline void pop_back() { this->strings.pop_back(); this->bInSafemode.pop_back(); };
   // the almighty algorithm.
   static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
+                                    std::vector<bool>& bInSafemode,
                                     const std::string& line,
                                     const std::string& delimiters = SubString::WhiteSpaces,
 …
                                     bool emptyEntries = false,
                                     char escape_char = '\\',
+                                    bool removeExcapeChar = true,
                                     char safemode_char = '"',
+                                    bool removeSafemodeChar = true,
                                     char openparenthesis_char = '(',
                                     char closeparenthesis_char = ')',
+                                    bool removeParenthesisChars = true,
                                     char comment_char = '\0',
                                     SPLIT_LINE_STATE start_state = SL_NORMAL);
 …
 private:
   std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
+  std::vector<bool>         bInSafemode;
 };

code/trunk/src/util/UtilPrereqs.h

r1024	r1052
61	61	class ArgReader;
62	62	class Convert;
63		~~template <typename FromType, typename ToType>~~
64		~~class Converter;~~
65	63	class MultiTypePrimitive;
66	64	class MultiTypeString;

code/trunk/src/util/tinyxml/ticpp.h

r871	r1052
973	973	Stream output operator.
974	974	*/
975		friend std::ostream& operator <<( std::ostream& out, Node& base )
	975	friend std::ostream& operator <<( std::ostream& out, const Node& base )
976	976	{
977	977	out << *base.GetTiXmlPointer();

Context Navigation

Legend:

Download in other formats: