Changeset 7203 in orxonox.OLD for branches/std/src/lib/util/loading

Timestamp:

Mar 9, 2006, 5:28:10 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: compiles again, BUT well…. i do not expect it to run anymore

Location:

branches/std/src/lib/util/loading

Files:

• game_loader.cc (modified) (6 diffs)
• game_loader.h (modified) (2 diffs)
• load_param.cc (modified) (7 diffs)
• load_param.h (modified) (3 diffs)
• load_param_description.cc (modified) (6 diffs)
• load_param_description.h (modified) (3 diffs)
• resource_manager.cc (modified) (48 diffs)
• resource_manager.h (modified) (5 diffs)

branches/std/src/lib/util/loading/game_loader.cc

@@ -86 +86 @@
  * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
  */
-ErrorMessage GameLoader::loadCampaign(const char* fileName)
+ErrorMessage GameLoader::loadCampaign(const std::string& fileName)
 {
   ErrorMessage errorCode;
-  char* campaignName = ResourceManager::getFullName(fileName);
-  if (campaignName)
+  std::string campaignName = ResourceManager::getFullName(fileName);
+  if (!campaignName.empty())
     {
       this->currentCampaign = this->fileToCampaign(campaignName);
-      delete[] campaignName;
     }
 }
@@ -105 +104 @@
  * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
  */
-ErrorMessage GameLoader::loadNetworkCampaign(const char* fileName)
+ErrorMessage GameLoader::loadNetworkCampaign(const std::string& fileName)
 {
   ErrorMessage errorCode;
-  char* campaignName = ResourceManager::getFullName(fileName);
-  if (campaignName)
+  std::string campaignName = ResourceManager::getFullName(fileName);
+  if (!campaignName.empty())
   {
     this->currentCampaign = this->fileToCampaign(campaignName);
-    delete[] campaignName;
   }
 }
@@ -220 +218 @@
  * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
  */
-Campaign* GameLoader::fileToCampaign(const char* fileName)
+Campaign* GameLoader::fileToCampaign(const std::string& fileName)
 {
   /* do not entirely load the campaign. just the current world
@@ -227 +225 @@
   */
 
-  if( fileName == NULL)
+  if( fileName.empty())
     {
       PRINTF(2)("No filename specified for loading");
@@ -233 +231 @@
     }
 
-  TiXmlDocument* XMLDoc = new TiXmlDocument( fileName);
+  TiXmlDocument XMLDoc(fileName);
   // load the campaign document
-  if( !XMLDoc->LoadFile())
+  if( !XMLDoc.LoadFile(fileName))
     {
       // report an error
-      PRINTF(1)("Could not load XML File %s: %s @ %d:%d\n", fileName, XMLDoc->ErrorDesc(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
-      delete XMLDoc;
+      PRINTF(1)("Could not load XML File %s: %s @ %d:%d\n", fileName.c_str(), XMLDoc.ErrorDesc(), XMLDoc.ErrorRow(), XMLDoc.ErrorCol());
       return NULL;
     }
 
   // check basic validity
-  TiXmlElement* root = XMLDoc->RootElement();
+  TiXmlElement* root = XMLDoc.RootElement();
   assert( root != NULL);
 
@@ -251 +248 @@
       // report an error
       PRINTF(2)("Specified XML File is not an orxonox campaign file (Campaign element missing)\n");
-      delete XMLDoc;
       return NULL;
     }
 
   // construct campaign
-  Campaign* c = new Campaign( root);
-
-  // free the XML data
-  delete XMLDoc;
-
-  return c;
+  return new Campaign( root);
 }
 

branches/std/src/lib/util/loading/game_loader.h

@@ -44 +44 @@
   static GameLoader* getInstance() { if(singletonRef == NULL) singletonRef = new GameLoader(); return singletonRef; }
 
-  ErrorMessage loadCampaign(const char* name);
+  ErrorMessage loadCampaign(const std::string& name);
   ErrorMessage loadDebugCampaign(Uint32 campaignID);
-  ErrorMessage loadNetworkCampaign(const char* fileName);
+  ErrorMessage loadNetworkCampaign(const std::string& fileName);
 
   ErrorMessage init();
@@ -62 +62 @@
   GameLoader ();
 
-  Campaign* fileToCampaign(const char* name);
+  Campaign* fileToCampaign(const std::string& name);
 
 

branches/std/src/lib/util/loading/load_param.cc

@@ -28 +28 @@
  * @param executor the Executor, that executes the loading procedure.
  */
-CLoadParam::CLoadParam(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
-{
-  this->paramName = paramName;
+CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
+  :  paramName(paramName), object(object)
+{
   this->object = object;
   this->inLoadCycle = inLoadCycle;
@@ -37 +37 @@
   if (likely(!inLoadCycle))
     this->loadElem = grabParameterElement(root, paramName);
-  //this->loadString = grabParameter(root, paramName);
-  else if (!strcmp(root->Value(), paramName))
+  else if (paramName == root->Value())
     this->loadElem = (TiXmlElement*)root->FirstChild();
   else
@@ -46 +45 @@
   this->executor = executor.clone();
 
-  if (this->executor)
-    this->executor->setName(paramName);
+  //if (this->executor)
+  //  this->executor->setName(paramName);
 }
 
@@ -60 +59 @@
   if (likely(this->executor != NULL))
   {
+    std::string loadString;
     if (this->loadElem != NULL &&  this->loadElem->ToText())
-      this->loadString = this->loadElem->Value();
-    else
-      this->loadString = NULL;
+      loadString = this->loadElem->Value();
     if (likely(this->object != NULL) &&
-        ( this->loadString != NULL ||
+        ( !loadString.empty() ||
           ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
     {
-      PRINTF(4)("Loading '%s' with Parameters '%s' onto: '%s'(%s)\n", this->paramName, this->loadString, this->object->getName(), this->object->getClassName());
-      this->executor->execute(this->object, this->loadString);
+      PRINTF(4)("Loading '%s' with Parameters '%s' onto: '%s'(%s)\n", this->paramName, loadString, this->object->getName(), this->object->getClassName());
+      this->executor->execute(this->object, &loadString);
     }
     delete this->executor;
@@ -99 +97 @@
  * @returns a pointer to itself.
 */
-CLoadParam& CLoadParam::describe(const char* descriptionText)
-{
-  if (LoadClassDescription::parametersDescription && this->paramDesc && !this->paramDesc->getDescription())
+CLoadParam& CLoadParam::describe(const std::string& descriptionText)
+{
+  if (LoadClassDescription::parametersDescription && this->paramDesc && this->paramDesc->getDescription().empty())
   {
     this->paramDesc->setDescription(descriptionText);
@@ -230 +228 @@
  * @returns the Value of the parameter if found, NULL otherwise
 */
-const char* grabParameter(const TiXmlElement* root, const char* parameterName)
+std::string grabParameter(const TiXmlElement* root, const std::string& parameterName)
 {
   const TiXmlElement* element;
   const TiXmlNode* node;
 
-  if (root == NULL || parameterName == NULL)
+  if (root == NULL)
     return NULL;
-  assert( parameterName != NULL);
 
   element = root->FirstChildElement( parameterName);
@@ -256 +253 @@
  * @returns the Element of the parameter if found, NULL otherwise
  */
-const TiXmlElement* grabParameterElement(const TiXmlElement* root, const char* parameterName)
+const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName)
 {
   const TiXmlElement* element;
   const TiXmlNode* node;
 
-  if (root == NULL || parameterName == NULL)
+  if (root == NULL)
     return NULL;
-  assert( parameterName != NULL);
 
   element = root->FirstChildElement( parameterName);

branches/std/src/lib/util/loading/load_param.h

@@ -87 +87 @@
 {
   public:
-    CLoadParam(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
+    CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
     virtual ~CLoadParam();
 
-    CLoadParam& describe(const char* descriptionText);
+    CLoadParam& describe(const std::string& descriptionText);
     CLoadParam& defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
                               const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
                               const MultiType& value4 = MT_NULL);
-    CLoadParam& attribute(const char* attributeName, const Executor& executor);
+    CLoadParam& attribute(const std::string& attributeName, const Executor& executor);
 
 
@@ -101 +101 @@
     Executor*                executor;
     BaseObject*              object;
-    const char*              paramName;
+    const std::string        paramName;
 
     LoadClassDescription*    classDesc;            //!< The LoadClassDescription of this CLoadParameter
     LoadParamDescription*    paramDesc;            //!< The LoadParameterDescription of this LoadParameter
     const TiXmlElement*      loadElem;             //!< The Element to load.
-    const char*              loadString;           //!< The string loaded by this LoadParam
     const void*              pointerToParam;       //!< A Pointer to a Parameter.
 
@@ -114 +113 @@
 // helper function
 
-const char* grabParameter(const TiXmlElement* root, const char* parameterName);
-const TiXmlElement* grabParameterElement(const TiXmlElement* root, const char* parameterName);
+std::string grabParameter(const TiXmlElement* root, const std::string& parameterName);
+const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
 
 #endif /* _LOAD_PARAM_H */

branches/std/src/lib/util/loading/load_param_description.cc

@@ -22 +22 @@
  * @param paramName the name of the parameter to load
  */
-LoadParamDescription::LoadParamDescription(const char* paramName)
+LoadParamDescription::LoadParamDescription(const std::string& paramName)
 {
   this->types = NULL;
-  this->description = NULL;
   this->defaultValues = NULL;
-  this->paramName = new char[strlen(paramName)+1];
-  strcpy(this->paramName, paramName);
+  this->paramName = paramName;
 }
 
@@ -46 +44 @@
   delete[] this->types;
   delete[] this->defaultValues;
-  delete[] this->paramName;
-  delete[] this->description;
 }
 
@@ -53 +49 @@
  * @param descriptionText The text to set as a description for this Parameter
  */
-void LoadParamDescription::setDescription(const char* descriptionText)
-{
-  this->description = new char[strlen(descriptionText)+1];
-  strcpy(this->description, descriptionText);
+void LoadParamDescription::setDescription(const std::string& descriptionText)
+{
+  this->description = descriptionText;
 }
 
@@ -64 +59 @@
 void LoadParamDescription::print() const
 {
-  PRINT(3)(" <%s>", this->paramName);
+  PRINT(3)(" <%s>", this->paramName.c_str());
   for (int i = 0; i < this->paramCount; i++)
   {
@@ -101 +96 @@
 //     }
   }
-  PRINT(3)("</%s>", this->paramName);
-  if (this->description)
-    PRINT(3)(" -- %s", this->description);
+  PRINT(3)("</%s>", this->paramName.c_str());
+  if (!this->description.empty())
+    PRINT(3)(" -- %s", this->description.c_str());
   // default values
   if (this->paramCount > 0)
@@ -213 +208 @@
   while (it != this->paramList.end())
   {
-    if (!strcmp((*it)->paramName, paramName))
+    if ((*it)->paramName == paramName)
     {
       return NULL;

branches/std/src/lib/util/loading/load_param_description.h

@@ -36 +36 @@
   friend class LoadParam;
   friend class LoadClassDescription;
- public:
-  LoadParamDescription(const char* paramName);
+public:
+  LoadParamDescription(const std::string& paramName);
   ~LoadParamDescription();
 
-  void setDescription(const char* descriptionText);
+  void setDescription(const std::string& descriptionText);
   /** @returns the descriptionString */
-  const char* getDescription() { return this->description; };
+  const std::string& getDescription() { return this->description; };
 
   void print() const;
 
- private:
-  char*         paramName;             //!< The name of the parameter.
+private:
+  std::string   paramName;             //!< The name of the parameter.
   int           paramCount;            //!< The count of parameters.
   int*          types;                 //!< What kind of parameters does this function take ??
-  char*         description;           //!< A longer description about this function.
+  std::string   description;           //!< A longer description about this function.
   char**        defaultValues;         //!< The 'Default Values'. @TODO MAKE THIS A MULTITYPE
 };
@@ -58 +58 @@
 {
   friend class CLoadParam;
- public:
+public:
   LoadClassDescription(const char* className);
   ~LoadClassDescription();
@@ -69 +69 @@
   static void printAll(const char* fileName = NULL);
   static std::list<const char*> searchClassWithShort(const char* classNameBegin);
-//  static const LoadParamDescription* getClass(const char* className);
+  //  static const LoadParamDescription* getClass(const char* className);
 
- private:
+private:
   static bool                              parametersDescription;  //!< if parameter-description should be enabled.
   static std::list<LoadClassDescription*>* classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)

branches/std/src/lib/util/loading/resource_manager.cc

@@ -60 +60 @@
 
   this->dataDir = new char[3];
-  strcpy(this->dataDir, "./");
+  this->dataDir = "./";
   this->tryDataDir("./data");
-
-  this->_cwd = NULL;
 }
 
@@ -80 +78 @@
     PRINTF(1)("Not removed all Resources, since there are still %d resources registered\n", this->resourceList.size());
 
-  // deleting the Directorie Lists
-  while (!this->imageDirs.empty())
-  {
-    delete[] this->imageDirs.back();
-    this->imageDirs.pop_back();
-  }
-
-  delete[] this->dataDir;
-  if (this->_cwd)
-    delete[] this->_cwd;
   ResourceManager::singletonRef = NULL;
 }
@@ -97 +85 @@
  * @param dataDir the DataDirectory.
  */
-bool ResourceManager::setDataDir(const char* dataDir)
-{
-  char* realDir = ResourceManager::homeDirCheck(dataDir);
+bool ResourceManager::setDataDir(const std::string& dataDir)
+{
+  std::string realDir = ResourceManager::homeDirCheck(dataDir);
   if (isDir(realDir))
   {
-    delete[] this->dataDir;
-    if (dataDir[strlen(dataDir)-1] == '/' || dataDir[strlen(dataDir)-1] == '\\')
+    if (dataDir[dataDir.size()-1] == '/' || dataDir[dataDir.size()-1] == '\\')
     {
-      this->dataDir = new char[strlen(realDir)+1];
-      strcpy(this->dataDir, realDir);
+      this->dataDir = realDir;
     }
     else
     {
-      this->dataDir = new char[strlen(realDir)+2];
-      strcpy(this->dataDir, realDir);
-      this->dataDir[strlen(realDir)] = '/';
-      this->dataDir[strlen(realDir)+1] = '\0';
+      this->dataDir = realDir;
+      this->dataDir += '/';
     }
-    delete[] realDir;
     return true;
   }
   else
   {
-    PRINTF(1)("%s is not a Directory, and can not be the Data Directory, leaving as %s \n", realDir, this->dataDir);
-    delete[] realDir;
+    PRINTF(1)("%s is not a Directory, and can not be the Data Directory, leaving as %s \n", realDir.c_str(), this->dataDir.c_str());
     return false;
   }
@@ -132 +114 @@
  * this is essentially the same as setDataDir, but it ommits the error-message
  */
-bool ResourceManager::tryDataDir(const char* dataDir)
-{
-  char* realDir = ResourceManager::homeDirCheck(dataDir);
+bool ResourceManager::tryDataDir(const std::string& dataDir)
+{
+  std::string realDir = ResourceManager::homeDirCheck(dataDir);
   if (isDir(realDir))
   {
-    delete[] this->dataDir;
-    if (dataDir[strlen(dataDir)-1] == '/' || dataDir[strlen(dataDir)-1] == '\\')
+    if (dataDir[dataDir.size()-1] == '/' || dataDir[dataDir.size()-1] == '\\')
     {
-      this->dataDir = new char[strlen(realDir)+1];
-      strcpy(this->dataDir, realDir);
+      this->dataDir = realDir;
     }
     else
     {
-      this->dataDir = new char[strlen(realDir)+2];
-      strcpy(this->dataDir, realDir);
-      this->dataDir[strlen(realDir)] = '/';
-      this->dataDir[strlen(realDir)+1] = '\0';
+      this->dataDir = realDir;
+      this->dataDir += '/';
     }
-    delete[] realDir;
     return true;
   }
-  delete[] realDir;
   return false;
 }
@@ -162 +138 @@
  * @param fileInside is iniside of the given directory.
 */
-bool ResourceManager::verifyDataDir(const char* fileInside)
+bool ResourceManager::verifyDataDir(const std::string& fileInside)
 {
   bool retVal;
   if (!isDir(this->dataDir))
   {
-    PRINTF(1)("%s is not a directory\n", this->dataDir);
-    return false;
-  }
-
-  char* testFile = new char[strlen(this->dataDir)+strlen(fileInside)+1];
-  sprintf(testFile, "%s%s", this->dataDir, fileInside);
+    PRINTF(1)("%s is not a directory\n", this->dataDir.c_str());
+    return false;
+  }
+
+  std::string testFile = this->dataDir + fileInside;
   retVal = isFile(testFile);
-  delete[] testFile;
   return retVal;
 }
@@ -185 +159 @@
    false otherwise
 */
-bool ResourceManager::addImageDir(const char* imageDir)
-{
-  if (imageDir == NULL)
-    return false;
-
-  char* newDir;
-  if (imageDir[strlen(imageDir)-1] == '/' || imageDir[strlen(imageDir)-1] == '\\')
-  {
-    newDir = new char[strlen(imageDir)+1];
-    strcpy(newDir, imageDir);
-  }
-  else
-  {
-    newDir = new char[strlen(imageDir)+2];
-    strcpy(newDir, imageDir);
-    newDir[strlen(imageDir)] = '/';
-    newDir[strlen(imageDir)+1] = '\0';
+bool ResourceManager::addImageDir(const std::string& imageDir)
+{
+  std::string newDir;
+  if (imageDir[imageDir.size()-1] == '/' || imageDir[imageDir.size()-1] == '\\')
+  {
+    newDir = imageDir;
+  }
+  else
+  {
+    newDir = imageDir;
+    newDir += '/';
   }
   // check if the param is a Directory
@@ -207 +175 @@
   {
     // check if the Directory has been added before
-    std::vector<char*>::const_iterator imageDir;
+    std::vector<std::string>::const_iterator imageDir;
     for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
     {
-      if (!strcmp(*imageDir, newDir))
+      if (*imageDir == newDir)
       {
-        PRINTF(3)("Path %s already loaded\n", newDir);
-        delete[] newDir;
+        PRINTF(3)("Path %s already loaded\n", newDir.c_str());
         return true;
       }
@@ -223 +190 @@
   else
   {
-    PRINTF(1)("%s is not a Directory, and can not be added to the Paths of Images\n", newDir);
-    delete[] newDir;
+    PRINTF(1)("%s is not a Directory, and can not be added to the Paths of Images\n", newDir.c_str());
     return false;
   }
@@ -239 +205 @@
  * @returns a pointer to a desired Resource.
 */
-BaseObject* ResourceManager::load(const char* fileName, ResourcePriority prio,
+BaseObject* ResourceManager::load(const std::string& fileName, ResourcePriority prio,
                                   const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
-  if (fileName == NULL)
-    return NULL;
   ResourceType tmpType;
 #ifndef NO_MODEL
 #define __IF_OK
-  if (!strncasecmp(fileName+(strlen(fileName)-4), ".obj", 4))
+  if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".obj", 4))
     tmpType = OBJ;
-  else if (!strncmp(fileName+(strlen(fileName)-4), ".md2", 4))
+  else if (!strncmp(fileName.c_str()+(fileName.size()-4), ".md2", 4))
     tmpType = MD2;
-  else if (!strcasecmp(fileName, "cube") ||
-           !strcasecmp(fileName, "sphere") ||
-           !strcasecmp(fileName, "plane") ||
-           !strcasecmp(fileName, "cylinder") ||
-           !strcasecmp(fileName, "cone"))
+  else if (!strcasecmp(fileName.c_str(), "cube") ||
+            !strcasecmp(fileName.c_str(), "sphere") ||
+            !strcasecmp(fileName.c_str(), "plane") ||
+            !strcasecmp(fileName.c_str(), "cylinder") ||
+            !strcasecmp(fileName.c_str(), "cone"))
     tmpType = PRIM;
 #endif /* NO_MODEL */
@@ -263 +227 @@
 #endif
 #define __IF_OK
-    if (!strncasecmp(fileName+(strlen(fileName)-4), ".wav", 4))
+    if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".wav", 4))
       tmpType = WAV;
-    else if (!strncasecmp(fileName+(strlen(fileName)-4), ".mp3", 4))
+    else if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".mp3", 4))
       tmpType = MP3;
-    else if (!strncasecmp(fileName+(strlen(fileName)-4), ".ogg", 4))
+    else if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".ogg", 4))
       tmpType = OGG;
 #endif /* NO_AUDIO */
@@ -275 +239 @@
 #endif
 #define __IF_OK
-      if (!strncasecmp(fileName+(strlen(fileName)-4), ".ttf", 4))
+      if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".ttf", 4))
         tmpType = TTF;
 #endif /* NO_TEXT */
@@ -283 +247 @@
 #endif
 #define __IF_OK
-        if (!strncasecmp(fileName+(strlen(fileName)-5), ".vert", 5))
+        if (!strncasecmp(fileName.c_str()+(fileName.size()-5), ".vert", 5))
           tmpType = SHADER;
 #endif /* NO_SHADERS */
@@ -308 +272 @@
  * during the initialisation instead of at Runtime.
  */
-bool ResourceManager::cache(const char* fileName, ResourceType type, ResourcePriority prio,
+bool ResourceManager::cache(const std::string& fileName, ResourceType type, ResourcePriority prio,
                             const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
-  assert(fileName != NULL);
-
   // searching if the resource was loaded before.
   Resource* tmpResource;
@@ -359 +321 @@
  * @returns a pointer to a desired Resource.
 */
-BaseObject* ResourceManager::load(const char* fileName, ResourceType type, ResourcePriority prio,
+BaseObject* ResourceManager::load(const std::string& fileName, ResourceType type, ResourcePriority prio,
                                   const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
-  assert(fileName != NULL);
-
   // searching if the resource was loaded before.
   Resource* tmpResource;
@@ -397 +357 @@
  * @returns a pointer to a desired Resource.
  */
-Resource* ResourceManager::loadResource(const char* fileName, ResourceType type, ResourcePriority prio,
+Resource* ResourceManager::loadResource(const std::string& fileName, ResourceType type, ResourcePriority prio,
                                         const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
@@ -406 +366 @@
   tmpResource->prio = prio;
   tmpResource->pointer = NULL;
-  tmpResource->name = new char[strlen(fileName)+1];
-  strcpy(tmpResource->name, fileName);
+  tmpResource->name = fileName;
 
   // creating the full name. (directoryName + FileName)
-  char* fullName = ResourceManager::getFullName(fileName);
+  std::string fullName = ResourceManager::getFullName(fileName);
   // Checking for the type of resource \see ResourceType
   switch(type)
@@ -425 +384 @@
       else
       {
-        PRINTF(2)("File %s in %s does not exist. Loading a cube-Model instead\n", fileName, dataDir);
+        PRINTF(2)("File %s in %s does not exist. Loading a cube-Model instead\n", fileName.c_str(), dataDir.c_str());
         tmpResource->pointer = ResourceManager::load("cube", PRIM, prio, tmpResource->param[0].getFloat());
       }
@@ -435 +394 @@
         tmpResource->param[0] = 1.0f;
 
-      if (!strcmp(tmpResource->name, "cube"))
+      if (tmpResource->name == "cube")
         tmpResource->pointer = new PrimitiveModel(PRIM_CUBE, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "sphere"))
+      else if (tmpResource->name == "sphere")
         tmpResource->pointer = new PrimitiveModel(PRIM_SPHERE, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "plane"))
+      else if (tmpResource->name == "plane")
         tmpResource->pointer = new PrimitiveModel(PRIM_PLANE, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "cylinder"))
+      else if (tmpResource->name == "cylinder")
         tmpResource->pointer = new PrimitiveModel(PRIM_CYLINDER, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "cone"))
+      else if (tmpResource->name == "cone")
         tmpResource->pointer = new PrimitiveModel(PRIM_CONE, tmpResource->param[0].getFloat());
       break;
@@ -468 +427 @@
         tmpResource->pointer = new Font(fullName, (unsigned int) tmpResource->param[0].getInt());
       else
-        PRINTF(2)("%s does not exist in %s. Not loading Font\n", fileName, this->dataDir);
+        PRINTF(2)("%s does not exist in %s. Not loading Font\n", fileName.c_str(), this->dataDir.c_str());
       break;
 #endif /* NO_TEXT */
@@ -494 +453 @@
       else
       {
-        std::vector<char*>::iterator imageDir;
+        std::vector<std::string>::iterator imageDir;
         for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
         {
-          char* imgName = new char[strlen(*imageDir)+strlen(fileName)+1];
-          sprintf(imgName, "%s%s", *imageDir, fileName);
+          std::string imgName = *imageDir + fileName;
           if(isFile(imgName))
           {
             PRINTF(4)("Image %s resides to %s\n", fileName, imgName);
             tmpResource->pointer = new Texture(imgName, tmpResource->param[0].getInt());
-            delete[] imgName;
             break;
           }
-          delete[] imgName;
         }
       }
       if(!tmpResource)
-        PRINTF(2)("!!Image %s not Found!!\n", fileName);
+        PRINTF(2)("!!Image %s not Found!!\n", fileName.c_str());
       break;
 #endif /* NO_TEXTURES */
@@ -520 +476 @@
         {
           MultiType param = param0; /// HACK
-          char* secFullName = ResourceManager::getFullName(param.getCString());
+          std::string secFullName = ResourceManager::getFullName(param.getCString());
           if (ResourceManager::isFile(secFullName))
           {
@@ -526 +482 @@
             tmpResource->pointer = new Shader(fullName, secFullName);
           }
-          delete[] secFullName;
         }
         else
@@ -538 +493 @@
     default:
       tmpResource->pointer = NULL;
-      PRINTF(1)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet. JUST DO IT!!\n", tmpResource->name);
+      PRINTF(1)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet. JUST DO IT!!\n", tmpResource->name.c_str());
       break;
   }
   if (tmpResource->pointer != NULL)
     this->resourceList.push_back(tmpResource);
-  delete[] fullName;
-
 
   if (tmpResource->pointer != NULL)
@@ -550 +503 @@
   else
   {
-    PRINTF(2)("Resource %s could not be loaded\n", fileName);
-    delete[] tmpResource->name;
+    PRINTF(2)("Resource %s could not be loaded\n", fileName.c_str());
     delete tmpResource;
     return NULL;
@@ -597 +549 @@
       delete resource->pointer;
       // deleting the List Entry:
-      PRINTF(4)("Resource %s safely removed.\n", resource->name);
-      delete[] resource->name;
+      PRINTF(4)("Resource %s safely removed.\n", resource->name.c_str());
       std::vector<Resource*>::iterator resourceIT = std::find(this->resourceList.begin(), this->resourceList.end(), resource);
       this->resourceList.erase(resourceIT);
@@ -604 +555 @@
     }
     else
-      PRINTF(4)("Resource %s not removed, because there are still %d References to it.\n", resource->name, resource->count);
-  }
-  else
-    PRINTF(4)("not deleting resource %s because DeleteLevel to high\n", resource->name);
+      PRINTF(4)("Resource %s not removed, because there are still %d References to it.\n", resource->name.c_str(), resource->count);
+  }
+  else
+    PRINTF(4)("not deleting resource %s because DeleteLevel to high\n", resource->name.c_str());
   return true;
 }
@@ -633 +584 @@
           if (round == 3)
             PRINTF(2)("unable to unload %s because there are still %d references to it\n",
-                      this->resourceList[index]->name, this->resourceList[index]->count);
+                      this->resourceList[index]->name.c_str(), this->resourceList[index]->count);
           removeCount++;
         }
@@ -653 +604 @@
  * @returns a Pointer to the Resource if found, NULL otherwise.
 */
-Resource* ResourceManager::locateResourceByInfo(const char* fileName, ResourceType type,
+Resource* ResourceManager::locateResourceByInfo(const std::string& fileName, ResourceType type,
     const MultiType& param0, const MultiType& param1, const MultiType& param2) const
 {
@@ -659 +610 @@
   for (resource = this->resourceList.begin(); resource != this->resourceList.end(); resource++)
   {
-    if ((*resource)->type == type && !strcmp(fileName, (*resource)->name))
+    if ((*resource)->type == type && fileName == (*resource)->name)
     {
       bool match = false;
@@ -743 +694 @@
 }
 
-char* ResourceManager::toResourcableString(unsigned int i)
-{
-  int len = strlen(ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
-  len += strlen(this->resourceList[i]->name);
+std::string ResourceManager::toResourcableString(unsigned int i)
+{
+/*  int len = strlen(ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
+  len += this->resourceList[i]->name.size();
   if (this->resourceList[i]->param[0].getCString()) len += strlen(this->resourceList[i]->param[0].getCString()) +1;
   if (this->resourceList[i]->param[1].getCString()) len += strlen(this->resourceList[i]->param[1].getCString()) +1;
   if (this->resourceList[i]->param[2].getCString()) len += strlen(this->resourceList[i]->param[2].getCString()) +1;
   len += 10;
-  char* tmp = new char[len];
+  std::string tmp = new char[len];
   tmp[0] = '\0';
-  strcat( tmp, ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
+  strcat(tmp, ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
   strcat(tmp,",");
   strcat (tmp, this->resourceList[i]->name);
@@ -771 +722 @@
     strcat( tmp, this->resourceList[i]->param[2].getCString());
   }
-  return tmp;
+  return tmp;*/
 }
 
@@ -778 +729 @@
  * @param resourceableString the String to cache the resource from.
  */
-bool ResourceManager::fromResourceableString(const char* resourceableString)
-{
-  SubString splits(resourceableString, ',');
+bool ResourceManager::fromResourceableString(const std::string& resourceableString)
+{
+/*  SubString splits(resourceableString, ',');
   splits.debug();
   if (splits.getCount() == 2)
@@ -793 +744 @@
   else if (splits.getCount() == 5)
     return this->cache(splits[1], ResourceManager::stringToResourceType(splits[0]),
-                RP_LEVEL, splits[2], splits[3], splits[4]);
+                RP_LEVEL, splits[2], splits[3], splits[4]);*/
 }
 
@@ -802 +753 @@
  * @returns true if it is a directory/symlink false otherwise
 */
-bool ResourceManager::isDir(const char* directoryName)
-{
-  if (directoryName == NULL)
-    return false;
-
-  char* tmpDirName = NULL;
+bool ResourceManager::isDir(const std::string& directoryName)
+{
+  std::string tmpDirName = directoryName;
   struct stat status;
 
   // checking for the termination of the string given. If there is a "/" at the end cut it away
-  if (directoryName[strlen(directoryName)-1] == '/' ||
-      directoryName[strlen(directoryName)-1] == '\\')
-  {
-    tmpDirName = new char[strlen(directoryName)];
-    strncpy(tmpDirName, directoryName, strlen(directoryName)-1);
-    tmpDirName[strlen(directoryName)-1] = '\0';
-  }
-  else
-  {
-    tmpDirName = new char[strlen(directoryName)+1];
-    strcpy(tmpDirName, directoryName);
-  }
-
-  if(!stat(tmpDirName, &status))
+  if (directoryName[directoryName.size()-1] == '/' ||
+      directoryName[directoryName.size()-1] == '\\')
+  {
+    tmpDirName.erase(tmpDirName.size()-1);
+  }
+
+  if(!stat(tmpDirName.c_str(), &status))
   {
     if (status.st_mode & (S_IFDIR
@@ -832 +773 @@
                          ))
     {
-      delete[] tmpDirName;
       return true;
     }
     else
-    {
-      delete[] tmpDirName;
       return false;
-    }
-  }
-  else
-  {
-    delete[] tmpDirName;
-    return false;
-  }
+  }
+  else
+    return false;
 }
 
@@ -853 +787 @@
  * @returns true if it is a regular file/symlink, false otherwise
 */
-bool ResourceManager::isFile(const char* fileName)
-{
-  if (fileName == NULL)
-    return false;
-  char* tmpFileName = ResourceManager::homeDirCheck(fileName);
+bool ResourceManager::isFile(const std::string& fileName)
+{
+  std::string tmpFileName = ResourceManager::homeDirCheck(fileName);
   // actually checks the File
   struct stat status;
-  if (!stat(tmpFileName, &status))
+  if (!stat(tmpFileName.c_str(), &status))
   {
     if (status.st_mode & (S_IFREG
@@ -868 +800 @@
                          ))
     {
-      delete[] tmpFileName;
       return true;
     }
     else
-    {
-      delete[] tmpFileName;
       return false;
-    }
-  }
-  else
-  {
-    delete[] tmpFileName;
-    return false;
-  }
+  }
+  else
+    return false;
 }
 
@@ -888 +813 @@
  * @param fileName The file to touch
 */
-bool ResourceManager::touchFile(const char* fileName)
-{
-  char* tmpName = ResourceManager::homeDirCheck(fileName);
-  if (tmpName == NULL)
+bool ResourceManager::touchFile(const std::string& fileName)
+{
+  std::string tmpName = ResourceManager::homeDirCheck(fileName);
+  if (tmpName.empty())
     return false;
   FILE* stream;
-  if( (stream = fopen (tmpName, "w")) == NULL)
-  {
-    PRINTF(1)("could not open %s fro writing\n", fileName);
-    delete[] tmpName;
+  if( (stream = fopen (tmpName.c_str(), "w")) == NULL)
+  {
+    PRINTF(1)("could not open %s fro writing\n", fileName.c_str());
     return false;
   }
   fclose(stream);
-
-  delete[] tmpName;
 }
 
@@ -909 +831 @@
  * @param fileName the File to delete
 */
-bool ResourceManager::deleteFile(const char* fileName)
-{
-  if (fileName == NULL)
-    return false;
-  char* tmpName = ResourceManager::homeDirCheck(fileName);
-  unlink(tmpName);
-  delete[] tmpName;
+bool ResourceManager::deleteFile(const std::string& fileName)
+{
+  std::string tmpName = ResourceManager::homeDirCheck(fileName);
+  unlink(tmpName.c_str());
 }
 
@@ -923 +842 @@
  * IMPORTANT: this has to be deleted from the outside
  */
-char* ResourceManager::homeDirCheck(const char* name)
-{
-  if (name == NULL)
-    return NULL;
-  char* retName;
-  if (!strncmp(name, "~/", 2))
+std::string ResourceManager::homeDirCheck(const std::string& name)
+{
+  std::string retName;
+  if (!strncmp(name.c_str(), "~/", 2))
   {
     char tmpFileName[500];
@@ -936 +853 @@
     strcpy(tmpFileName, getenv("HOME"));
 #endif
-    retName = new char[strlen(tmpFileName)+strlen(name)];
-    sprintf(retName, "%s%s", tmpFileName, name+1);
-  }
-  else
-  {
-    retName = new char[strlen(name)+1];
-    strcpy(retName, name);
+    retName = tmpFileName + name;
+  }
+  else
+  {
+    retName = name;
   }
   return retName;
@@ -949 +864 @@
 /**
  * @param name the relative name of the File/Directory.
- * @returns a new char* with the name in abs-dir-format
- */
-char* ResourceManager::getAbsDir(const char* name)
-{
-  if (name == NULL)
-    return NULL;
-  char* retName;
-  if (strncmp(name, "/", 1))
-  {
-    if (*name == '.' && *(name+1) != '.')
-      name++;
-    const char* absDir = ResourceManager::cwd();
-    retName = new char[strlen(absDir)+strlen(name)+1];
-    sprintf(retName, "%s%s", absDir, name);
-  }
-  else
-  {
-    retName = new char[strlen(name)+1];
-    strcpy(retName, name);
+ * @returns a new std::string with the name in abs-dir-format
+ */
+std::string ResourceManager::getAbsDir(const std::string& name)
+{
+  if (name.empty())
+    return "";
+  std::string retName = name;
+  if (strncmp(name.c_str(), "/", 1))
+  {
+    if (name[0] == '.' && name[1] != '.')
+      retName.erase(0);
+    const std::string& absDir = ResourceManager::cwd();
+    retName = absDir + retName;
   }
   return retName;
@@ -978 +887 @@
  * !!IMPORTANT: this has to be deleted from the outside!!
 */
-char* ResourceManager::getFullName(const char* fileName)
-{
-  if (fileName == NULL || ResourceManager::getInstance()->getDataDir() == NULL)
+std::string ResourceManager::getFullName(const std::string& fileName)
+{
+  if (fileName.empty() || ResourceManager::getInstance()->getDataDir().empty())
     return NULL;
 
-  char* retName = new char[strlen(ResourceManager::getInstance()->getDataDir())
-                           + strlen(fileName) + 1];
-  sprintf(retName, "%s%s", ResourceManager::getInstance()->getDataDir(), fileName);
+  std::string retName = ResourceManager::getInstance()->getDataDir() +fileName;
   if (ResourceManager::isFile(retName) || ResourceManager::isDir(retName))
     return retName;
   else
-  {
-    delete[] retName;
     return NULL;
-  }
 }
 
@@ -1005 +909 @@
  * @returns the Current Woring Directory
  */
-const char* ResourceManager::cwd()
-{
-  if (ResourceManager::getInstance()->_cwd == NULL)
+const std::string& ResourceManager::cwd()
+{
+  if (ResourceManager::getInstance()->_cwd.empty())
   {
     char cwd[1024];
     char* errorCode = getcwd(cwd, 1024);
     if (errorCode == 0)
-      return NULL;
-
-    ResourceManager::getInstance()->_cwd = new char[strlen(cwd)+1];
-    strcpy(ResourceManager::getInstance()->_cwd, cwd);
+      return ResourceManager::getInstance()->_cwd;
+
+    ResourceManager::getInstance()->_cwd = cwd;
   }
   return ResourceManager::getInstance()->_cwd;
@@ -1026 +929 @@
  * @returns true if the file exists, false otherwise
  */
-bool ResourceManager::isInDataDir(const char* fileName)
-{
-  if (fileName == NULL || ResourceManager::getInstance()->getDataDir() == NULL)
+bool ResourceManager::isInDataDir(const std::string& fileName)
+{
+  if (fileName.empty() || ResourceManager::getInstance()->getDataDir().empty())
     return false;
 
   bool retVal = false;
-  char* checkFile = new char[strlen(ResourceManager::getInstance()->getDataDir())
-                             + strlen(fileName) + 1];
-  sprintf(checkFile, "%s%s", ResourceManager::getInstance()->getDataDir(), fileName);
+  std::string checkFile = ResourceManager::getInstance()->getDataDir() + fileName;
 
   if (ResourceManager::isFile(checkFile) || ResourceManager::isDir(checkFile))
@@ -1040 +941 @@
   else
     retVal = false;
-  delete[] checkFile;
   return retVal;
 }
@@ -1055 +955 @@
   // if it is not initialized
   PRINT(0)(" Reference is: %p\n", ResourceManager::singletonRef);
-  PRINT(0)(" Data-Directory is: %s\n", this->dataDir);
+  PRINT(0)(" Data-Directory is: %s\n", this->dataDir.c_str());
   PRINT(0)(" List of Image-Directories: ");
-  std::vector<char*>::const_iterator imageDir;
+  std::vector<std::string>::const_iterator imageDir;
   for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
-    PRINT(0)("%s ", (*imageDir));
+    PRINT(0)("%s ", (*imageDir).c_str());
   PRINT(0)("\n");
 
@@ -1068 +968 @@
   {
     PRINT(0)("-----------------------------------------\n");
-    PRINT(0)("Name: %s; References: %d; Type: %s ", (*resource)->name, (*resource)->count, ResourceManager::ResourceTypeToChar((*resource)->type));
+    PRINT(0)("Name: %s; References: %d; Type: %s ", (*resource)->name.c_str(), (*resource)->count, ResourceManager::ResourceTypeToChar((*resource)->type));
 
     PRINT(0)("gets deleted at ");

branches/std/src/lib/util/loading/resource_manager.h

@@ -71 +71 @@
   unsigned int      count;             //!< How many times this Resource has been loaded.
 
-  char*             name;              //!< Name of the Resource.
+  std::string       name;              //!< Name of the Resource.
   ResourceType      type;              //!< ResourceType of this Resource.
   ResourcePriority  prio;              //!< The Priority of this resource. (This will only be increased)
@@ -96 +96 @@
   inline static ResourceManager* getInstance() { if (!singletonRef) singletonRef = new ResourceManager();  return singletonRef; };
 
-  bool setDataDir(const char* dataDir);
+  bool setDataDir(const std::string& dataDir);
   /** @returns the Name of the data directory */
-  inline const char* getDataDir() const { return this->dataDir; };
+  inline const std::string& getDataDir() const { return this->dataDir; };
 
 
-  bool tryDataDir(const char* dataDir);
-  bool verifyDataDir(const char* fileInside);
-  bool addImageDir(const char* imageDir);
+  bool tryDataDir(const std::string& dataDir);
+  bool verifyDataDir(const std::string& fileInside);
+  bool addImageDir(const std::string& imageDir);
 
-  bool cache(const char* fileName, ResourceType type, ResourcePriority prio = RP_NO,
+  bool cache(const std::string& fileName, ResourceType type, ResourcePriority prio = RP_NO,
              const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
   BaseObject* copy(BaseObject* resourcePointer);
 
-  BaseObject* load(const char* fileName, ResourcePriority prio = RP_NO,
+  BaseObject* load(const std::string& fileName, ResourcePriority prio = RP_NO,
                    const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
-  BaseObject* load(const char* fileName, ResourceType type, ResourcePriority prio = RP_NO,
+  BaseObject* load(const std::string& fileName, ResourceType type, ResourcePriority prio = RP_NO,
                    const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
   bool unload(BaseObject* pointer, ResourcePriority prio = RP_NO);
@@ -117 +117 @@
   bool unloadAllByPriority(ResourcePriority prio);
 
-  Resource* locateResourceByInfo(const char* fileName, ResourceType type,
+  Resource* locateResourceByInfo(const std::string& fileName, ResourceType type,
                                  const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType()) const;
   Resource* locateResourceByPointer(const void* pointer) const;
 
-  char* toResourcableString(unsigned int i);
-  bool fromResourceableString(const char* resourceableString);
+  std::string toResourcableString(unsigned int i);
+  bool fromResourceableString(const std::string& resourceableString);
   /** @returns the Count of Resources the ResourceManager handles */
   unsigned int resourceCount() const { return this->resourceList.size(); }
@@ -130 +130 @@
 
   // utility functions for handling files in and around the data-directory
-  static bool isDir(const char* directory);
-  static bool isFile(const char* fileName);
-  static bool touchFile(const char* fileName);
-  static bool deleteFile(const char* fileName);
-  static char* homeDirCheck(const char* fileName);
-  static char* getFullName(const char* fileName);
-  static bool isInDataDir(const char* fileName);
-  static char* getAbsDir(const char* fileName);
-  static const char* cwd();
+  static bool isDir(const std::string& directory);
+  static bool isFile(const std::string& fileName);
+  static bool touchFile(const std::string& fileName);
+  static bool deleteFile(const std::string& fileName);
+  static std::string homeDirCheck(const std::string& fileName);
+  static std::string getFullName(const std::string& fileName);
+  static bool isInDataDir(const std::string& fileName);
+  static std::string getAbsDir(const std::string& fileName);
+  static const std::string& cwd();
 
   static const char* ResourceTypeToChar(ResourceType type);
@@ -145 +145 @@
  private:
   ResourceManager();
-  Resource* loadResource(const char* fileName, ResourceType type, ResourcePriority prio,
+  Resource* loadResource(const std::string& fileName, ResourceType type, ResourcePriority prio,
                          const MultiType& param0, const MultiType& param1, const MultiType& param2);
 
  private:
-  static ResourceManager*  singletonRef;       //!< singleton Reference
+  static ResourceManager*    singletonRef;       //!< singleton Reference
 
-  char*                    _cwd;               //!< The currend Working directory.
-  char*                    dataDir;            //!< The Data Directory, where all relevant Data is stored.
-  std::vector<char*>       imageDirs;          //!< A list of directories in which images are stored.
+  std::string                _cwd;               //!< The currend Working directory.
+  std::string                dataDir;            //!< The Data Directory, where all relevant Data is stored.
+  std::vector<std::string>   imageDirs;          //!< A list of directories in which images are stored.
 
-  std::vector<Resource*>   resourceList;       //!< The List of Resources, that has already been loaded.
+  std::vector<Resource*>     resourceList;       //!< The List of Resources, that has already been loaded.
 
-  static const char*       resourceNames[RESOURCE_TYPE_SIZE];
+  static const char*         resourceNames[RESOURCE_TYPE_SIZE];
 };