Changeset 708 for code/branches/FICN/src/orxonox/core

Timestamp:

Dec 28, 2007, 10:30:29 PM (17 years ago)

Author:

rgrieder

Message:

• added Vector2, Vector3, Matrix3, ColourValue, Quaternion and String to the misc folder as header files (each of them contains #include <string> … typedef std::string String , etc.)
• please use String from now on by including <misc/String.h"
• removed #include <OgreVector3.h", etc. from "CoreIncludes.h" (adjusted all source files)
• adjusted all the source files (except network, that keeps <string> for the moment) (what a mess..)
• moved usleep hack to misc/Sleep.h
• relative include paths for files from other root directories (like misc, network, etc.) (but it stills writes "../Orxonox.h" when in folder orxonox/objects)
• "OgreSceneManager.h" —> <OgreSceneManager.h>
• included OrxonoxPrereqs in every file in folder orxonox
• moved HUD and ParticleInterface to namespace orxonox
• removed some using namespace Ogre/std when appropriate
• I hope I haven't forgotten important points..

Location:

code/branches/FICN/src/orxonox/core

Files:

• ArgReader.cc (modified) (4 diffs)
• ArgReader.h (modified) (3 diffs)
• ClassFactory.h (modified) (3 diffs)
• ConfigValueContainer.cc (modified) (43 diffs)
• ConfigValueContainer.h (modified) (4 diffs)
• CoreIncludes.h (modified) (1 diff)
• CorePrereqs.h (modified) (1 diff)
• Debug.h (modified) (1 diff)
• DebugLevel.h (modified) (1 diff)
• Error.cc (modified) (2 diffs)
• Error.h (modified) (2 diffs)
• Factory.cc (modified) (3 diffs)
• Factory.h (modified) (3 diffs)
• Identifier.cc (modified) (1 diff)
• Identifier.h (modified) (9 diffs)
• IdentifierList.cc (modified) (2 diffs)
• IdentifierList.h (modified) (2 diffs)
• Language.cc (modified) (11 diffs)
• Language.h (modified) (3 diffs)
• OrxonoxClass.h (modified) (3 diffs)
• OutputHandler.cc (modified) (2 diffs)
• OutputHandler.h (modified) (2 diffs)

code/branches/FICN/src/orxonox/core/ArgReader.cc

@@ -45 +45 @@
   }
 
-  void ArgReader::checkArgument(std::string option, std::string &string, bool must)
+  void ArgReader::checkArgument(String option, String &string, bool must)
   {
     int argpos = checkOption(option) + 1;
@@ -62 +62 @@
   }
 
-  void ArgReader::checkArgument(std::string option, int &integer, bool must)
+  void ArgReader::checkArgument(String option, int &integer, bool must)
   {
     int argpos = checkOption(option) + 1;
@@ -78 +78 @@
   }
 
-  void ArgReader::checkArgument(std::string option, float &floating, bool must)
+  void ArgReader::checkArgument(String option, float &floating, bool must)
   {
     int argpos = checkOption(option) + 1;
@@ -94 +94 @@
   }
 
-  int ArgReader::checkOption(std::string option)
+  int ArgReader::checkOption(String option)
   {
     for(int i = 1; i < counter_; i++)

code/branches/FICN/src/orxonox/core/ArgReader.h

@@ -35 +35 @@
 #define _ArgReader_H__
 
-#include <string>
+#include "CorePrereqs.h"
 
-#include "CorePrereqs.h"
+#include "misc/String.h"
 
 namespace orxonox {
@@ -45 +45 @@
     public:
       ArgReader(int argc, char **argv);
-      void checkArgument(std::string option, std::string& string, bool must=false);
-      void checkArgument(std::string option, int& integer, bool must=false);
-      void checkArgument(std::string option, float& floating, bool must=false);
+      void checkArgument(String option, String& string, bool must=false);
+      void checkArgument(String option, int& integer, bool must=false);
+      void checkArgument(String option, float& floating, bool must=false);
       bool errorHandling();
     private:
-      int checkOption(std::string option);
+      int checkOption(String option);
 
     private:
@@ -56 +56 @@
       char **arguments_;
       bool fail_;
-      std::string errorStr_;
+      String errorStr_;
   };
 

code/branches/FICN/src/orxonox/core/ClassFactory.h

@@ -36 +36 @@
 #define _ClassFactory_H__
 
-#include <string>
-
 #include "CorePrereqs.h"
 
+#include "misc/String.h"
 #include "Factory.h"
 #include "Identifier.h"
@@ -54 +53 @@
     {
         public:
-            static bool create(const std::string& name);
+            static bool create(const String& name);
             BaseObject* fabricate();
 
@@ -70 +69 @@
     */
     template <class T>
-    bool ClassFactory<T>::create(const std::string& name)
+    bool ClassFactory<T>::create(const String& name)
     {
         COUT(4) << "*** Create entry for " << name << " in Factory." << std::endl;

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

@@ -28 +28 @@
 #include <fstream>
 
-#include "../../misc/Tokenizer.h"
-#include "../../misc/String2Number.h"
+#include "misc/Tokenizer.h"
+#include "misc/String2Number.h"
 #include "ConfigValueContainer.h"
 
@@ -43 +43 @@
         @param defvalue The default-value
     */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, int defvalue)
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, int defvalue)
     {
         this->bAddedDescription_ = false;
@@ -53 +53 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned int defvalue)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, unsigned int defvalue)
     {
         this->bAddedDescription_ = false;
@@ -75 +75 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, char defvalue)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, char defvalue)
     {
         this->bAddedDescription_ = false;
@@ -97 +97 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned char defvalue)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, unsigned char defvalue)
     {
         this->bAddedDescription_ = false;
@@ -119 +119 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, float defvalue)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, float defvalue)
     {
         this->bAddedDescription_ = false;
@@ -141 +141 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, double defvalue)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, double defvalue)
     {
         this->bAddedDescription_ = false;
@@ -163 +163 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, long double defvalue)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, long double defvalue)
     {
         this->bAddedDescription_ = false;
@@ -185 +185 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, bool defvalue)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, bool defvalue)
     {
         this->bAddedDescription_ = false;
@@ -211 +211 @@
 
         this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, const std::string& defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = String;
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, const String& defvalue)
+    {
+        this->bAddedDescription_ = false;
+        this->classname_ = classname;
+        this->varname_ = varname;
+        this->type_ = _String;
 
         this->defvalueString_ = "\"" + defvalue + "\"";                             // Convert the string to a "config-file-string" with quotes
         this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, const char* defvalue)
+        String valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, const char* defvalue)
     {
         this->bAddedDescription_ = false;
@@ -251 +251 @@
         this->type_ = ConstChar;
 
-        this->defvalueString_ = "\"" + std::string(defvalue) + "\"";                // Convert the string to a "config-file-string" with quotes
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, Ogre::Vector2 defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = Vector2;
+        this->defvalueString_ = "\"" + String(defvalue) + "\"";                // Convert the string to a "config-file-string" with quotes
+        this->searchConfigFileLine();                                               // Search the entry in the config-file
+        String valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, Vector2 defvalue)
+    {
+        this->bAddedDescription_ = false;
+        this->classname_ = classname;
+        this->varname_ = varname;
+        this->type_ = _Vector2;
 
         // Try to convert the default-value from Vector2 to string
@@ -280 +280 @@
 
         this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, Ogre::Vector3 defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = Vector3;
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, Vector3 defvalue)
+    {
+        this->bAddedDescription_ = false;
+        this->classname_ = classname;
+        this->varname_ = varname;
+        this->type_ = _Vector3;
 
         // Try to convert the default-value from Vector3 to string
@@ -307 +307 @@
 
         this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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 varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, Ogre::ColourValue defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = ColourValue;
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @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 varname The name of the variable
+        @param defvalue The default-value
+    */
+    ConfigValueContainer::ConfigValueContainer(const String& classname, const String& varname, ColourValue defvalue)
+    {
+        this->bAddedDescription_ = false;
+        this->classname_ = classname;
+        this->varname_ = varname;
+        this->type_ = _ColourValue;
 
         // Try to convert the default-value from ColourValue to string
@@ -334 +334 @@
 
         this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @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
-        @return True if the string was successfully parsed
-    */
-    bool ConfigValueContainer::parseSting(const std::string& input)
+        String valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+            this->resetConfigFileEntry();                                           // The conversion failed
+    }
+
+    /**
+        @brief Parses a given String into a value of the type of the associated variable and assigns it.
+        @param input The string to convert
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseSting(const String& input)
     {
         if (this->type_ == ConfigValueContainer::Int)
@@ -362 +362 @@
         else if (this->type_ == ConfigValueContainer::Bool)
             return this->parseSting(input, this->value_.value_bool_);
-        else if (this->type_ == ConfigValueContainer::String)
+        else if (this->type_ == ConfigValueContainer::_String)
             return this->parseSting(input, this->value_string_);
         else if (this->type_ == ConfigValueContainer::ConstChar)
             return this->parseSting(input, this->value_string_);
-        else if (this->type_ == ConfigValueContainer::Vector2)
+        else if (this->type_ == ConfigValueContainer::_Vector2)
             return this->parseSting(input, this->value_vector2_);
-        else if (this->type_ == ConfigValueContainer::Vector3)
+        else if (this->type_ == ConfigValueContainer::_Vector3)
             return this->parseSting(input, this->value_vector3_);
-        else if (this->type_ == ConfigValueContainer::ColourValue)
+        else if (this->type_ == ConfigValueContainer::_ColourValue)
             return this->parseSting(input, this->value_colourvalue_);
 
@@ -377 +377 @@
 
     /**
-        @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::parseSting(const std::string& input, int defvalue)
+        @brief Parses a given 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::parseSting(const String& input, int defvalue)
     {
         return string2Number(this->value_.value_int_, input, defvalue);
@@ -388 +388 @@
 
     /**
-        @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::parseSting(const std::string& input, unsigned int defvalue)
+        @brief Parses a given 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::parseSting(const String& input, unsigned int defvalue)
     {
         return string2Number(this->value_.value_uint_, input, defvalue);
@@ -399 +399 @@
 
     /**
-        @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::parseSting(const std::string& input, char defvalue)
+        @brief Parses a given 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::parseSting(const String& input, char defvalue)
     {
         // I used value_int_ instead of value_char_ to avoid number <-> char confusion in the config-file
@@ -411 +411 @@
 
     /**
-        @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::parseSting(const std::string& input, unsigned char defvalue)
+        @brief Parses a given 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::parseSting(const String& input, unsigned char defvalue)
     {
         // I used value_uint_ instead of value_uchar_ to avoid number <-> char confusion in the config-file
@@ -423 +423 @@
 
     /**
-        @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::parseSting(const std::string& input, float defvalue)
+        @brief Parses a given 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::parseSting(const String& input, float defvalue)
     {
         return string2Number(this->value_.value_float_, input, defvalue);
@@ -434 +434 @@
 
     /**
-        @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::parseSting(const std::string& input, double defvalue)
+        @brief Parses a given 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::parseSting(const String& input, double defvalue)
     {
         return string2Number(this->value_.value_double_, input, defvalue);
@@ -445 +445 @@
 
     /**
-        @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::parseSting(const std::string& input, long double defvalue)
+        @brief Parses a given 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::parseSting(const String& input, long double defvalue)
     {
         return string2Number(this->value_.value_long_double_, input, defvalue);
@@ -456 +456 @@
 
     /**
-        @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::parseSting(const std::string& input, bool defvalue)
+        @brief Parses a given 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::parseSting(const String& input, bool defvalue)
     {
         // Try to parse the value-string - is it a word?
@@ -484 +484 @@
 
     /**
-        @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::parseSting(const std::string& input, const std::string& defvalue)
+        @brief Parses a given String into a value of the type 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::parseSting(const String& input, const String& defvalue)
     {
         // Strip the quotes
@@ -509 +509 @@
 
     /**
-        @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::parseSting(const std::string& input, const char* defvalue)
+        @brief Parses a given 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::parseSting(const String& input, const char* defvalue)
     {
         // Strip the quotes
@@ -534 +534 @@
 
     /**
-        @brief Parses a given std::string into a value of the type Ogre::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::parseSting(const std::string& input, const Ogre::Vector2& defvalue)
+        @brief Parses a given 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::parseSting(const String& input, const Vector2& defvalue)
     {
         // Strip the value-string
@@ -548 +548 @@
         if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
         {
-            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            std::vector<String> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
             if (!string2Number(this->value_vector2_.x, tokens[0], defvalue.x))
             {
@@ -568 +568 @@
 
     /**
-        @brief Parses a given std::string into a value of the type Ogre::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::parseSting(const std::string& input, const Ogre::Vector3& defvalue)
+        @brief Parses a given 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::parseSting(const String& input, const Vector3& defvalue)
     {
         // Strip the value-string
@@ -582 +582 @@
         if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
         {
-            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            std::vector<String> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
             if (!string2Number(this->value_vector3_.x, tokens[0], defvalue.x))
             {
@@ -607 +607 @@
 
     /**
-        @brief Parses a given std::string into a value of the type Ogre::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::parseSting(const std::string& input, const Ogre::ColourValue& defvalue)
+        @brief Parses a given 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::parseSting(const String& input, const ColourValue& defvalue)
     {
         // Strip the value-string
@@ -621 +621 @@
         if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
         {
-            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            std::vector<String> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
             if (!string2Number(this->value_colourvalue_.r, tokens[0], defvalue.r))
             {
@@ -678 +678 @@
 
         // The string of the section we're searching
-        std::string section = "";
+        String section = "";
         section.append("[");
         section.append(this->classname_);
@@ -685 +685 @@
         // Iterate through all config-file-lines
         bool success = false;
-        std::list<std::string>::iterator it1;
+        std::list<String>::iterator it1;
         for(it1 = ConfigValueContainer::getConfigFileLines().begin(); it1 != ConfigValueContainer::getConfigFileLines().end(); ++it1)
         {
@@ -696 +696 @@
                 // We found the right section
                 bool bLineIsEmpty = false;
-                std::list<std::string>::iterator positionToPutNewLineAt;
+                std::list<String>::iterator positionToPutNewLineAt;
 
                 // Iterate through all lines in the section
-                std::list<std::string>::iterator it2;
+                std::list<String>::iterator it2;
                 for(it2 = ++it1; it2 != ConfigValueContainer::getConfigFileLines().end(); ++it2)
                 {
@@ -777 +777 @@
         @return True = it's a comment
     */
-    bool ConfigValueContainer::isComment(const std::string& line)
+    bool ConfigValueContainer::isComment(const String& line)
     {
         // Strip the line, whitespaces are disturbing
-        std::string teststring = getStrippedLine(line);
+        String teststring = getStrippedLine(line);
 
         // There are four possible comment-symbols:
@@ -798 +798 @@
         @return True = it's empty
     */
-    bool ConfigValueContainer::isEmpty(const std::string& line)
+    bool ConfigValueContainer::isEmpty(const String& line)
     {
         return getStrippedLine(line) == "";
@@ -808 +808 @@
         @return The stripped line
     */
-    std::string ConfigValueContainer::getStrippedLine(const std::string& line)
-    {
-        std::string output = line;
+    String ConfigValueContainer::getStrippedLine(const String& line)
+    {
+        String output = line;
         unsigned int pos;
         while ((pos = output.find(" ")) < output.length())
@@ -825 +825 @@
         @return The value-string
     */
-    std::string ConfigValueContainer::parseValueString(bool bStripped)
-    {
-        std::string output;
+    String ConfigValueContainer::parseValueString(bool bStripped)
+    {
+        String output;
         if (bStripped)
             output = this->getStrippedLine(*this->configFileLine_);
@@ -839 +839 @@
         @returns a list, containing all entrys in the config-file.
     */
-    std::list<std::string>& ConfigValueContainer::getConfigFileLines()
+    std::list<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>();
+        static std::list<String> configFileLinesStaticReference = std::list<String>();
         return configFileLinesStaticReference;
     }
@@ -866 +866 @@
         @param filename The name of the config-file
     */
-    void ConfigValueContainer::readConfigFile(const std::string& filename)
+    void ConfigValueContainer::readConfigFile(const String& filename)
     {
         // This creates the file if it's not existing
@@ -913 +913 @@
         @param filename The name of the config-file
     */
-    void ConfigValueContainer::writeConfigFile(const std::string& filename)
+    void ConfigValueContainer::writeConfigFile(const String& filename)
     {
         // Make sure we stored the config-file in the list
@@ -930 +930 @@
 
         // Iterate through the list an write the lines into the file
-        std::list<std::string>::iterator it;
+        std::list<String>::iterator it;
         for (it = ConfigValueContainer::getConfigFileLines().begin(); it != ConfigValueContainer::getConfigFileLines().end(); ++it)
         {
@@ -943 +943 @@
         @param description The description
     */
-    void ConfigValueContainer::description(const std::string& description)
+    void ConfigValueContainer::description(const String& description)
     {
         if (!this->bAddedDescription_)
         {
-            this->description_ = std::string("ConfigValueDescription::" + this->classname_ + "::" + this->varname_);
+            this->description_ = String("ConfigValueDescription::" + this->classname_ + "::" + this->varname_);
             Language::getLanguage().addEntry(description_, description);
             this->bAddedDescription_ = true;

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

@@ -43 +43 @@
 #define _ConfigValueContainer_H__
 
-#include <string>
 #include <list>
 
 #include "CorePrereqs.h"
 
-#include "OgreVector2.h"
-#include "OgreVector3.h"
-#include "OgreColourValue.h"
+#include "misc/Vector2.h"
+#include "misc/Vector3.h"
+#include "misc/Matrix3.h"
+#include "misc/Quaternion.h"
+#include "misc/String.h"
+#include "misc/ColourValue.h"
 #include "Language.h"
 
@@ -85 +87 @@
                 Bool,
                 ConstChar,
-                String,
-                Vector2,
-                Vector3,
-                ColourValue
+                _String,
+                _Vector2,
+                _Vector3,
+                _ColourValue
             };
 
-            ConfigValueContainer(const std::string& classname, const std::string& varname, int defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned int defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, char defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned char defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, float defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, double defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, long double defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, bool defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, const std::string& defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, const char* defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, Ogre::Vector2 defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, Ogre::Vector3 defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, Ogre::ColourValue defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, int defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, unsigned int defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, char defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, unsigned char defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, float defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, double defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, long double defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, bool defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, const String& defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, const char* defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, Vector2 defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, Vector3 defvalue);
+            ConfigValueContainer(const String& classname, const String& varname, ColourValue defvalue);
 
             /** @returns the value. @param value This is only needed to determine the right type. */
@@ -122 +124 @@
             inline ConfigValueContainer& getValue(bool& value)                          { value = this->value_.value_bool_; return *this; }
             /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(std::string& value)                   { value = this->value_string_; return *this; }
+            inline ConfigValueContainer& getValue(String& value)                   { value = this->value_string_; return *this; }
             /** @returns the value. @param value This is only needed to determine the right type. */
             inline ConfigValueContainer& getValue(const char* value)                    { value = this->value_string_.c_str(); return *this; }
             /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(Ogre::Vector2& value)                 { value = this->value_vector2_; return *this; }
+            inline ConfigValueContainer& getValue(Vector2& value)                 { value = this->value_vector2_; return *this; }
             /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(Ogre::Vector3& value)                 { value = this->value_vector3_; return *this; }
+            inline ConfigValueContainer& getValue(Vector3& value)                 { value = this->value_vector3_; return *this; }
             /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(Ogre::ColourValue& value)             { value = this->value_colourvalue_; return *this; }
+            inline ConfigValueContainer& getValue(ColourValue& value)             { value = this->value_colourvalue_; return *this; }
 
-            void description(const std::string& description);
+            void description(const String& description);
 
-            bool parseSting(const std::string& input);
+            bool parseSting(const String& input);
             void resetConfigFileEntry();
             void resetConfigValue();
 
-            static std::string getStrippedLine(const std::string& line);
-            static bool isEmpty(const std::string& line);
-            static bool isComment(const std::string& line);
+            static String getStrippedLine(const String& line);
+            static bool isEmpty(const String& line);
+            static bool isComment(const String& line);
 
         private:
-            bool parseSting(const std::string& input, int defvalue);
-            bool parseSting(const std::string& input, unsigned int defvalue);
-            bool parseSting(const std::string& input, char defvalue);
-            bool parseSting(const std::string& input, unsigned char defvalue);
-            bool parseSting(const std::string& input, float defvalue);
-            bool parseSting(const std::string& input, double defvalue);
-            bool parseSting(const std::string& input, long double defvalue);
-            bool parseSting(const std::string& input, bool defvalue);
-            bool parseSting(const std::string& input, const std::string& defvalue);
-            bool parseSting(const std::string& input, const char* defvalue);
-            bool parseSting(const std::string& input, const Ogre::Vector2& defvalue);
-            bool parseSting(const std::string& input, const Ogre::Vector3& defvalue);
-            bool parseSting(const std::string& input, const Ogre::ColourValue& defvalue);
+            bool parseSting(const String& input, int defvalue);
+            bool parseSting(const String& input, unsigned int defvalue);
+            bool parseSting(const String& input, char defvalue);
+            bool parseSting(const String& input, unsigned char defvalue);
+            bool parseSting(const String& input, float defvalue);
+            bool parseSting(const String& input, double defvalue);
+            bool parseSting(const String& input, long double defvalue);
+            bool parseSting(const String& input, bool defvalue);
+            bool parseSting(const String& input, const String& defvalue);
+            bool parseSting(const String& input, const char* defvalue);
+            bool parseSting(const String& input, const Vector2& defvalue);
+            bool parseSting(const String& input, const Vector3& defvalue);
+            bool parseSting(const String& input, const ColourValue& defvalue);
 
-            static std::list<std::string>& getConfigFileLines();
+            static std::list<String>& getConfigFileLines();
             static bool finishedReadingConfigFile(bool finished = false);
             void searchConfigFileLine();
-            std::string parseValueString(bool bStripped = true);
+            String parseValueString(bool bStripped = true);
 
-            static void readConfigFile(const std::string& filename);
-            static void writeConfigFile(const std::string& filename);
+            static void readConfigFile(const String& filename);
+            static void writeConfigFile(const String& filename);
 
-            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
+            String         classname_;                     //!< The name of the class the variable belongs to
+            String         varname_;                       //!< The name of the variable
+            String         defvalueString_;                //!< The string of the default-variable
 
             union MultiType
@@ -181 +183 @@
             } value_;                                           //!< The value of the variable
 
-            std::string         value_string_;                  //!< The value, if the variable is of the type string
-            Ogre::Vector2       value_vector2_;                 //!< The value, if the variable is of the type Vector2
-            Ogre::Vector3       value_vector3_;                 //!< The value, if the variable is of the type Vector3
-            Ogre::ColourValue   value_colourvalue_;             //!< The value, if the variable is of the type ColourValue
+            String         value_string_;                  //!< The value, if the variable is of the type string
+            Vector2       value_vector2_;                 //!< The value, if the variable is of the type Vector2
+            Vector3       value_vector3_;                 //!< The value, if the variable is of the type Vector3
+            ColourValue   value_colourvalue_;             //!< The value, if the variable is of the type ColourValue
 
-            std::list<std::string>::iterator configFileLine_;   //!< An iterator, pointing to the entry of the variable in the config-file
+            std::list<String>::iterator configFileLine_;   //!< An iterator, pointing to the entry of the variable in the config-file
 
             VariableType type_;                                 //!< The type of the variable

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

@@ -50 +50 @@
 #include "ConfigValueContainer.h"
 #include "Debug.h"
-
-#include "OgreVector2.h"
-#include "OgreVector3.h"
-#include "OgreColourValue.h"
-#include "OgreQuaternion.h"
-#include "OgreMatrix3.h"
-
-
-// Some typedefs
-namespace orxonox
-{
-    typedef Ogre::Vector2 Vector2;
-    typedef Ogre::Vector3 Vector3;
-    typedef Ogre::ColourValue ColourValue;
-    typedef Ogre::Radian Radian;
-    typedef Ogre::Degree Degree;
-    typedef Ogre::Real Real;
-    typedef Ogre::Quaternion Quaternion;
-    typedef Ogre::Matrix3 Matrix3;
-}
-
 
 /**

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

@@ -34 +34 @@
 #define _CorePrereqs_H__
 
-#include "../OrxonoxPlatform.h"
+#include "orxonox/OrxonoxPlatform.h"
 
 //-----------------------------------------------------------------------

code/branches/FICN/src/orxonox/core/Debug.h

@@ -37 +37 @@
 
 #include <stdio.h>
+
+#include "CorePrereqs.h"
+
 #include "OutputHandler.h"
-
-#include "CorePrereqs.h"
 
 extern "C" _CoreExport int getSoftDebugLevel();

code/branches/FICN/src/orxonox/core/DebugLevel.h

@@ -38 +38 @@
 
 #include "CorePrereqs.h"
+
 #include "OrxonoxClass.h"
 #include "OutputHandler.h"

code/branches/FICN/src/orxonox/core/Error.cc

@@ -26 +26 @@
  */
 
+#include "Debug.h"
 #include "Error.h"
-#include "Debug.h"
 
 namespace orxonox
@@ -36 +36 @@
         }
 
-        Error::Error(std::string errorMsg, int errorCode)
+        Error::Error(String errorMsg, int errorCode)
         {
                 Error(errorCode, errorMsg);
         }
 
-        Error::Error(int errorCode, std::string errorMsg)
+        Error::Error(int errorCode, String errorMsg)
         {
                 COUT(1) << "############################ "<< std::endl

code/branches/FICN/src/orxonox/core/Error.h

@@ -29 +29 @@
 #define _Error_H__
 
-#include <string>
+#include "CorePrereqs.h"
 
-#include "CorePrereqs.h"
+#include "misc/String.h"
 
 namespace orxonox
@@ -39 +39 @@
         public:
                 Error();
-                Error(std::string errorMsg, int errorCode=0);
-                Error(int errorCode, std::string errorMsg="");
+                Error(String errorMsg, int errorCode = 0);
+                Error(int errorCode, String errorMsg = "");
         private:
 

code/branches/FICN/src/orxonox/core/Factory.cc

@@ -42 +42 @@
         @param name The name of the wanted Identifier
     */
-    Identifier* Factory::getIdentifier(const std::string& name)
+    Identifier* Factory::getIdentifier(const String& name)
     {
         return getFactoryPointer()->identifierStringMap_[name];
@@ -61 +61 @@
         @param identifier The identifier to add
     */
-    void Factory::add(const std::string& name, Identifier* identifier)
+    void Factory::add(const String& name, Identifier* identifier)
     {
         getFactoryPointer()->identifierStringMap_[name] = identifier;
@@ -85 +85 @@
     {
         COUT(3) << "*** Factory -> Create class-hierarchy" << std::endl;
-        std::map<std::string, Identifier*>::iterator it;
+        std::map<String, Identifier*>::iterator it;
         it = getFactoryPointer()->identifierStringMap_.begin();
         (*getFactoryPointer()->identifierStringMap_.begin()).second->startCreatingHierarchy();

code/branches/FICN/src/orxonox/core/Factory.h

@@ -45 +45 @@
 
 #include <map>
-#include <string>
 
 #include "CorePrereqs.h"
+
+#include "misc/String.h"
 
 namespace orxonox
@@ -60 +61 @@
     {
         public:
-            static Identifier* getIdentifier(const std::string& name);
+            static Identifier* getIdentifier(const String& name);
             static Identifier* getIdentifier(const unsigned int id);
-            static void add(const std::string& name, Identifier* identifier);
+            static void add(const String& name, Identifier* identifier);
             static void changeNetworkID(Identifier* identifier, const unsigned int oldID, const unsigned int newID);
             static void createClassHierarchy();
 
-            static Factory* getFactoryPointer();// avoid overriding pointer_s in the static intialisation process
+            static Factory* getFactoryPointer();    // avoid overriding order problem in the static intialisation process
 
         private:
@@ -73 +74 @@
             ~Factory() {}                           // don't delete
 
-            std::map<std::string, Identifier*> identifierStringMap_;            //!< The map, mapping the name with the Identifier
+            std::map<String, Identifier*> identifierStringMap_;            //!< The map, mapping the name with the Identifier
             std::map<unsigned int, Identifier*> identifierNetworkIDMap_;        //!< The map, mapping the network ID with the Identifier
     };

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

@@ -118 +118 @@
         @returns a reference to the Identifier map, containing all Identifiers.
     */
-    std::map<std::string, Identifier*>& Identifier::getIdentifierMap()
+    std::map<String, Identifier*>& Identifier::getIdentifierMap()
     {
-        static std::map<std::string, Identifier*> identifierMapStaticReference = std::map<std::string, Identifier*>();
+        static std::map<String, Identifier*> identifierMapStaticReference = std::map<String, Identifier*>();
         return identifierMapStaticReference;
     }

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

@@ -52 +52 @@
 #define _Identifier_H__
 
-#include <string>
 #include <map>
 
 #include "CorePrereqs.h"
 
+#include "misc/String.h"
 #include "ObjectList.h"
 #include "IdentifierList.h"
@@ -112 +112 @@
 
             /** @returns the name of the class the Identifier belongs to. */
-            inline const std::string& getName() const { return this->name_; }
+            inline const String& getName() const { return this->name_; }
 
             /** @returns the parents of the class the Identifier belongs to. */
@@ -130 +130 @@
 
             /** @returns the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variable */
-            inline ConfigValueContainer* getConfigValueContainer(const std::string& varname)
+            inline ConfigValueContainer* getConfigValueContainer(const String& varname)
                 { return this->configValues_[varname]; }
 
             /** @brief Sets the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variablee @param container The container */
-            inline void setConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
+            inline void setConfigValueContainer(const String& varname, ConfigValueContainer* container)
                 { this->configValues_[varname] = container; }
 
-            static std::map<std::string, Identifier*>& getIdentifierMap();
+            static std::map<String, Identifier*>& getIdentifierMap();
 
         private:
@@ -166 +166 @@
             IdentifierList* children_;                                  //!< The Children of the class the Identifier belongs to
 
-            std::string name_;                                          //!< The name of the class the Identifier belongs to
+            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)
@@ -172 +172 @@
             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::map<String, ConfigValueContainer*> configValues_; //!< A map to link the string of configurable variables with their ConfigValueContainer
     };
 
@@ -189 +189 @@
     {
         public:
-            static ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass);
+            static ClassIdentifier<T>* registerClass(const IdentifierList* parents, const String& name, bool bRootClass);
             static void addObject(T* object);
             static ClassIdentifier<T>* getIdentifier();
-            void setName(const std::string& name);
+            void setName(const String& name);
 
         private:
@@ -221 +221 @@
     */
     template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass)
+    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const String& name, bool bRootClass)
     {
         COUT(4) << "*** Register Class in " << name << "-Singleton." << std::endl;
@@ -265 +265 @@
     */
     template <class T>
-    void ClassIdentifier<T>::setName(const std::string& name)
+    void ClassIdentifier<T>::setName(const String& name)
     {
         // Make sure we didn't already set the name, to avoid duplicate entries in the Identifier map
@@ -271 +271 @@
         {
             this->name_ = name;
-            this->getIdentifierMap().insert(std::pair<std::string, Identifier*>(name, this));
+            this->getIdentifierMap().insert(std::pair<String, Identifier*>(name, this));
             this->bSetName_ = true;
         }

code/branches/FICN/src/orxonox/core/IdentifierList.cc

@@ -31 +31 @@
 */
 
+#include "Identifier.h"
 #include "IdentifierList.h"
-#include "Identifier.h"
 
 namespace orxonox
@@ -130 +130 @@
         @returns a string, containing a list of the names of all Identifiers in the list.
     */
-    std::string IdentifierList::toString() const
+    String IdentifierList::toString() const
     {
         IdentifierListElement* temp = this->first_;
-        std::string output = "";
+        String output = "";
 
         while (temp)

code/branches/FICN/src/orxonox/core/IdentifierList.h

@@ -37 +37 @@
 #define _IdentifierList_H__
 
-#include <string>
+#include "CorePrereqs.h"
 
-#include "CorePrereqs.h"
+#include "misc/String.h"
 
 namespace orxonox
@@ -62 +62 @@
             void remove(const Identifier* identifier);
             bool isInList(const Identifier* identifier) const;
-            std::string toString() const;
+            String toString() const;
 
             IdentifierListElement* first_;      //!< The first element in the list

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

@@ -28 +28 @@
 #include <fstream>
 
+#include "CoreIncludes.h"
 #include "Language.h"
-#include "CoreIncludes.h"
 
 namespace orxonox
@@ -36 +36 @@
     // ###      LanguageEntry      ###
     // ###############################
-    LanguageEntry::LanguageEntry(const std::string& fallbackEntry)
+    LanguageEntry::LanguageEntry(const String& fallbackEntry)
     {
         RegisterRootObject(LanguageEntry);
@@ -44 +44 @@
     }
 
-    void LanguageEntry::setTranslation(const std::string& translation)
+    void LanguageEntry::setTranslation(const String& translation)
     {
         if (translation.compare("") != 0)
@@ -52 +52 @@
     }
 
-    void LanguageEntry::setDefault(const std::string& fallbackEntry)
+    void LanguageEntry::setDefault(const String& fallbackEntry)
     {
         if (this->translatedEntry_.compare(this->fallbackEntry_) == 0)
@@ -85 +85 @@
     }
 
-    void Language::createEntry(const LanguageEntryName& name, const std::string& entry)
+    void Language::createEntry(const LanguageEntryName& name, const String& entry)
     {
         if (!this->languageEntries_[name])
@@ -99 +99 @@
     }
 
-    void Language::addEntry(const LanguageEntryName& name, const std::string& entry)
-    {
-        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(name);
+    void Language::addEntry(const LanguageEntryName& name, const String& entry)
+    {
+        std::map<String, LanguageEntry*>::const_iterator it = this->languageEntries_.find(name);
         if (!it->second)
             this->createEntry(name, entry);
@@ -112 +112 @@
     }
 
-    const std::string& Language::getTranslation(const LanguageEntryName& name) const
-    {
-        std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(name);
+    const String& Language::getTranslation(const LanguageEntryName& name) const
+    {
+        std::map<String, LanguageEntry*>::const_iterator it = this->languageEntries_.find(name);
         if (it->second)
             return it->second->getTranslation();
@@ -124 +124 @@
     }
 
-    const std::string Language::getFileName(const std::string& language)
-    {
-        return std::string("translation_" + language + ".lang");
+    const String Language::getFileName(const String& language)
+    {
+        return String("translation_" + language + ".lang");
     }
 
@@ -154 +154 @@
         {
             file.getline(line, 1024);
-            std::string lineString = std::string(line);
+            String lineString = String(line);
             if (lineString.compare("") != 0)
             {
@@ -190 +190 @@
         {
             file.getline(line, 1024);
-            std::string lineString = std::string(line);
+            String lineString = String(line);
             if (lineString.compare("") != 0)
             {
@@ -196 +196 @@
                 if (pos < lineString.size() && lineString.size() >= 3)
                 {
-                    std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(lineString.substr(0, pos));
+                    std::map<String, LanguageEntry*>::const_iterator it = this->languageEntries_.find(lineString.substr(0, pos));
                     if (it->second)
                         it->second->setTranslation(lineString.substr(pos + 1));

code/branches/FICN/src/orxonox/core/Language.h

@@ -29 +29 @@
 #define _Language_H__
 
-#include <string>
 #include <map>
 
 #include "CorePrereqs.h"
 
+#include "misc/String.h"
 #include "OrxonoxClass.h"
 
 namespace orxonox
 {
-    typedef std::string LanguageEntryName;
+    typedef String LanguageEntryName;
 
     class _CoreExport LanguageEntry : public OrxonoxClass
     {
         public:
-            explicit LanguageEntry(const std::string& fallbackEntry);
-            void setTranslation(const std::string& translation);
-            void setDefault(const std::string& fallbackEntry);
+            explicit LanguageEntry(const String& fallbackEntry);
+            void setTranslation(const String& translation);
+            void setDefault(const String& fallbackEntry);
 
-            inline const std::string& getTranslation()
+            inline const String& getTranslation()
                 { return this->translatedEntry_; }
 
-            inline const std::string& getDefault()
+            inline const String& getDefault()
                 { return this->fallbackEntry_; }
 
         private:
-            std::string fallbackEntry_;
-            std::string translatedEntry_;
+            String fallbackEntry_;
+            String translatedEntry_;
     };
 
@@ -63 +63 @@
             static Language& getLanguage();
             void setConfigValues();
-            void addEntry(const LanguageEntryName& name, const std::string& entry);
-            const std::string& getTranslation(const LanguageEntryName& name) const;
+            void addEntry(const LanguageEntryName& name, const String& entry);
+            const String& getTranslation(const LanguageEntryName& name) const;
 
         private:
@@ -74 +74 @@
             void readTranslatedLanguageFile();
             void writeDefaultLanguageFile() const;
-            static const std::string getFileName(const std::string& language);
-            void createEntry(const LanguageEntryName& name, const std::string& entry);
+            static const String getFileName(const String& language);
+            void createEntry(const LanguageEntryName& name, const String& entry);
 
-            std::string language_;
-            std::string defaultLanguage_;
-            std::string defaultTranslation_;
-            std::map<std::string, LanguageEntry*> languageEntries_;
+            String language_;
+            String defaultLanguage_;
+            String defaultTranslation_;
+            std::map<String, LanguageEntry*> languageEntries_;
     };
 }

code/branches/FICN/src/orxonox/core/OrxonoxClass.h

@@ -37 +37 @@
 #define _OrxonoxClass_H__
 
-#include <string>
-
 #include "CorePrereqs.h"
 
+#include "misc/String.h"
 #include "MetaObjectList.h"
 #include "Identifier.h"
@@ -133 +132 @@
 
             /** @brief Sets the name of the object. @param name The name */
-            inline virtual void setName(const std::string& name) { this->name_ = name; }
+            inline virtual void setName(const String& name) { this->name_ = name; }
 
             /** @returns the name of the object. */
-            inline const std::string& getName() const { return this->name_; }
+            inline const String& getName() const { return this->name_; }
 
             /** @brief Sets the state of the objects activity. @param bActive True = active */
@@ -155 +154 @@
             MetaObjectList metaList_;       //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
 
-            std::string name_;              //!< The name of the object
+            String name_;              //!< The name of the object
             bool bActive_;                  //!< True = the object is active
             bool bVisible_;                 //!< True = the object is visible

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

@@ -26 +26 @@
  */
 
+#include "DebugLevel.h"
 #include "OutputHandler.h"
-#include "DebugLevel.h"
 
 namespace orxonox
@@ -35 +35 @@
         @param logfilename The name of the logfile
     */
-    OutputHandler::OutputHandler(const std::string& logfilename)
+    OutputHandler::OutputHandler(const String& logfilename)
     {
         this->logfilename_ = logfilename;

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

@@ -37 +37 @@
 #define _OutputHandler_H__
 
-#include "CorePrereqs.h"
-
 #include <iostream>
 #include <fstream>
-#include <string>
+
+#include "misc/String.h"
+#include "CorePrereqs.h"
 
 namespace orxonox
@@ -108 +108 @@
 
         private:
-            explicit OutputHandler(const std::string& logfilename);
+            explicit OutputHandler(const String& logfilename);
             OutputHandler(const OutputHandler& oh) {}; // don't copy
             virtual ~OutputHandler();
             std::ofstream logfile_;     //!< The logfile where the output is logged
-            std::string logfilename_;   //!< The name of the logfile
+            String logfilename_;   //!< The name of the logfile
             int outputLevel_;           //!< The level of the incoming output
     };