Changeset 7216 in orxonox.OLD for branches/std/src/lib

Timestamp:

Mar 12, 2006, 8:54:30 AM (19 years ago)

Author:

bensch

Message:

orxonox/std:: compile and run again, with many more std::strings….

Location:

branches/std/src/lib

Files:

• coord/p_node.cc (modified) (5 diffs)
• coord/p_node.h (modified) (4 diffs)
• graphics/effects/fog_effect.cc (modified) (1 diff)
• graphics/effects/fog_effect.h (modified) (2 diffs)
• graphics/effects/lense_flare.cc (modified) (3 diffs)
• graphics/effects/lense_flare.h (modified) (1 diff)
• graphics/render2D/billboard.cc (modified) (2 diffs)
• graphics/render2D/billboard.h (modified) (1 diff)
• graphics/render2D/element_2d.cc (modified) (10 diffs)
• graphics/render2D/element_2d.h (modified) (6 diffs)
• graphics/text_engine/text.cc (modified) (8 diffs)
• graphics/text_engine/text.h (modified) (2 diffs)
• lang/base_object.cc (modified) (1 diff)
• lang/class_list.cc (modified) (15 diffs)
• lang/class_list.h (modified) (4 diffs)
• particles/dot_particles.h (modified) (1 diff)
• particles/model_particles.cc (modified) (1 diff)
• particles/model_particles.h (modified) (1 diff)
• particles/sprite_particles.cc (modified) (1 diff)
• particles/sprite_particles.h (modified) (1 diff)
• physics/physics_connection.cc (modified) (2 diffs)
• physics/physics_connection.h (modified) (1 diff)
• physics/physics_engine.cc (modified) (3 diffs)
• physics/physics_engine.h (modified) (1 diff)
• shell/shell.cc (modified) (10 diffs)
• shell/shell.h (modified) (4 diffs)
• shell/shell_command.cc (modified) (4 diffs)
• shell/shell_command.h (modified) (1 diff)
• shell/shell_command_class.cc (modified) (10 diffs)
• shell/shell_command_class.h (modified) (2 diffs)
• shell/shell_completion.cc (modified) (7 diffs)
• shell/shell_completion.h (modified) (1 diff)
• shell/shell_input.cc (modified) (14 diffs)
• shell/shell_input.h (modified) (3 diffs)
• util/executor/executor.h (modified) (1 diff)
• util/executor/functor_list.h (modified) (2 diffs)
• util/helper_functions.cc (modified) (1 diff)
• util/loading/load_param.cc (modified) (1 diff)

branches/std/src/lib/coord/p_node.cc

@@ -540 +540 @@
  * @param childName the name of the child to add to this PNode
  */
-void PNode::addChild (const char* childName)
+void PNode::addChild (const std::string& childName)
 {
   PNode* childNode = dynamic_cast<PNode*>(ClassList::getObject(childName, CL_PARENT_NODE));
@@ -624 +624 @@
  * @param parentName the name of the Parent to set to this PNode
  */
-void PNode::setParent (const char* parentName)
+void PNode::setParent (const std::string& parentName)
 {
   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
@@ -631 +631 @@
   else
     PRINTF(2)("Not Found PNode's (%s::%s) new Parent by Name: %s\n",
-              this->getClassName(), this->getName(), parentName);
+        this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -699 +699 @@
  * @param parentMode a String representing this parentingMode
  */
-void PNode::setParentMode (const char* parentingMode)
+void PNode::setParentMode (const std::string& parentingMode)
 {
   this->setParentMode(PNode::charToParentingMode(parentingMode));
@@ -1068 +1068 @@
  * @return the int corresponding to the named parentingMode
  */
-PARENT_MODE PNode::charToParentingMode(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+PARENT_MODE PNode::charToParentingMode(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (PNODE_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (PNODE_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (PNODE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (PNODE_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (PNODE_ROTATE_AND_MOVE);
 }

branches/std/src/lib/coord/p_node.h

@@ -143 +143 @@
   // PARENTING //
   void addChild (PNode* child);
-  void addChild (const char* childName);
+  void addChild (const std::string& childName);
   void removeChild (PNode* child);
   void removeNode();
@@ -151 +151 @@
   /** @param parent the new parent of this node */
   inline void setParent (PNode* parent) { parent->addChild(this); };
-  void setParent (const char* parentName);
+  void setParent (const std::string& parentName);
   /** @returns the parent of this PNode */
   inline PNode* getParent () const { return this->parent; };
@@ -162 +162 @@
   // PARENTING_MODE AND OTHER FLAGS //
   void setParentMode (PARENT_MODE parentMode);
-  void setParentMode (const char* parentingMode);
+  void setParentMode (const std::string& parentingMode);
   /** @returns the Parenting mode of this node */
   int getParentMode() const { return 0x000f & this->parentMode; };
@@ -184 +184 @@
   // HELPER_FUNCTIONS //
   static const char* parentingModeToChar(int parentingMode);
-  static PARENT_MODE charToParentingMode(const char* parentingMode);
+  static PARENT_MODE charToParentingMode(const std::string& parentingMode);
   float distance(const PNode* node) const { return (this->getAbsCoor() - node->getAbsCoor()).len(); };
 

branches/std/src/lib/graphics/effects/fog_effect.cc

@@ -126 +126 @@
  * @param mode the mode character
  */
-GLint FogEffect::charToFogMode(const char* mode)
+GLint FogEffect::stringToFogMode(const std::string& mode)
 {
-  if( !strcmp( "GL_LINEAR", mode))
+  if(mode == "GL_LINEAR")
     return GL_LINEAR;
-  else if( !strcmp("GL_EXP", mode))
+  else if(mode == "GL_EXP")
     return GL_EXP;
-  else if(!strcmp("GL_EXP2", mode) )
+  else if(mode == "GL_EXP2" )
     return GL_EXP2;
   else

branches/std/src/lib/graphics/effects/fog_effect.h

@@ -26 +26 @@
     virtual bool deactivate();
 
-    inline void setFogMode(const char* mode) { this->fogMode = this->charToFogMode(mode); }
+    inline void setFogMode(const std::string& mode) { this->fogMode = this->stringToFogMode(mode); }
     inline void setFogDensity(float density) { this->fogDensity = density; }
     inline void setFogRange(float start, float end) { this->fogStart = start; this->fogEnd = end; }
@@ -33 +33 @@
 
   private:
-    GLint charToFogMode(const char* mode);
+    GLint stringToFogMode(const std::string& mode);
 
 

branches/std/src/lib/graphics/effects/lense_flare.cc

@@ -147 +147 @@
  *  7th: Texture of the third burst
  */
-void LenseFlare::addFlare(const char* textureName)
+void LenseFlare::addFlare(const std::string& textureName)
 {
   if( this->flares.size() > LF_MAX_FLARES)
@@ -159 +159 @@
   bb->setSize(50, 50);
   this->flares.push_back(bb);
-  PRINTF(0)("Added a Lenseflare Billboard with texture %s\n", textureName);
+  PRINTF(4)("Added a Lenseflare Billboard with texture %s\n", textureName.c_str());
 
   // the first flare belongs to the light source
@@ -167 +167 @@
     bb->setVisibility(true);
   }
-  PRINTF(0)("Finished adding\n", textureName);
+  PRINTF(4)("Finished adding\n");
 }
 

branches/std/src/lib/graphics/effects/lense_flare.h

@@ -39 +39 @@
     virtual void tick(float dt);
 
-    void addFlare(const char* textureName);
+    void addFlare(const std::string& textureName);
 
 

branches/std/src/lib/graphics/render2D/billboard.cc

@@ -78 +78 @@
 void Billboard::loadParams(const TiXmlElement* root)
 {
-  LoadParam(root, "texture", this, Billboard, setTexture)
+  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
       .describe("the texture-file to load onto the Billboard");
 
@@ -100 +100 @@
  * @param textureFile The texture-file to load onto the crosshair
  */
-void Billboard::setTexture(const char* textureFile)
+void Billboard::setTexture(const std::string& textureFile)
 {
   this->material->setDiffuseMap(textureFile);

branches/std/src/lib/graphics/render2D/billboard.h

@@ -30 +30 @@
 
     void setSize(float sizeX, float sizeY);
-    void setTexture(const char* textureFile);
+    void setTexture(const std::string& textureFile);
     void attachTo(PNode* pnode);
 

branches/std/src/lib/graphics/render2D/element_2d.cc

@@ -180 +180 @@
  * @param alignment the alignment @see loadParams
 */
-void Element2D::setAlignment(const char* alignment)
-{
-  if (!strcmp(alignment, "center"))
+void Element2D::setAlignment(const std::string& alignment)
+{
+  if (alignment == "center")
     this->setAlignment(E2D_ALIGN_CENTER);
-  else if (!strcmp(alignment, "left"))
+  else if (alignment == "left")
     this->setAlignment(E2D_ALIGN_LEFT);
-  else if (!strcmp(alignment, "right"))
+  else if (alignment == "right")
     this->setAlignment(E2D_ALIGN_RIGHT);
-  else if (!strcmp(alignment, "screen-center"))
+  else if (alignment == "screen-center")
     this->setAlignment(E2D_ALIGN_SCREEN_CENTER);
 }
@@ -213 +213 @@
 /**
  * sets the layer onto which this 2D-element is projected to.
- * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const char* layer)
- */
-void Element2D::setLayer(const char* layer)
+ * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const std::string& layer)
+ */
+void Element2D::setLayer(const std::string& layer)
 {
   this->setLayer(Element2D::charToLayer2D(layer));
@@ -235 +235 @@
  * @param bindNode the name of the Node (should be existing)
  */
-void Element2D::setBindNode(const char* bindNode)
+void Element2D::setBindNode(const std::string& bindNode)
 {
   const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
@@ -572 +572 @@
  * @param childName the name of the child to add to this PNode
  */
-void Element2D::addChild2D (const char* childName)
+void Element2D::addChild2D (const std::string& childName)
 {
   Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
@@ -651 +651 @@
  * @param parentName the name of the Parent to set to this Element2D
  */
-void Element2D::setParent2D (const char* parentName)
+void Element2D::setParent2D (const std::string& parentName)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -658 +658 @@
   else
     PRINTF(2)("Not Found Element2D's (%s::%s) new Parent by Name: %s\n",
-                this->getClassName(), this->getName(), parentName);
+                this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -704 +704 @@
  * @param bias the speed to iterate to this new Positions
  */
-void Element2D::setParentSoft2D(const char* parentName, float bias)
+void Element2D::setParentSoft2D(const std::string& parentName, float bias)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -724 +724 @@
  * @param parentMode a String representing this parentingMode
  */
-void Element2D::setParentMode2D (const char* parentingMode)
+void Element2D::setParentMode2D (const std::string& parentingMode)
 {
   this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
@@ -1093 +1093 @@
  * @return the int corresponding to the named parentingMode
  */
-E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+E2D_PARENT_MODE Element2D::charToParentingMode2D(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (E2D_PARENT_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (E2D_PARENT_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (E2D_PARENT_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (E2D_PARENT_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (E2D_PARENT_ROTATE_AND_MOVE);
 }
@@ -1139 +1139 @@
  * @returns the E2D_LAYER on success, E2D_DEFAULT_LAYER on error.
  */
-E2D_LAYER Element2D::charToLayer2D(const char* layer)
-{
-  if (!strcmp(layer, "top"))
+E2D_LAYER Element2D::charToLayer2D(const std::string& layer)
+{
+  if (layer =="top")
     return (E2D_LAYER_TOP);
-  else  if (!strcmp(layer, "medium"))
+  else  if (layer == "medium")
     return (E2D_LAYER_MEDIUM);
-  else  if (!strcmp(layer, "bottom"))
+  else  if (layer == "bottom")
     return (E2D_LAYER_BOTTOM);
-  else  if (!strcmp(layer, "below-all"))
+  else  if (layer == "below-all")
     return (E2D_LAYER_BELOW_ALL);
   else

branches/std/src/lib/graphics/render2D/element_2d.h

@@ -102 +102 @@
     /** @param alignment the new Alignment of the 2D-Element */
     inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
-    void setAlignment(const char* alignment);
+    void setAlignment(const std::string& alignment);
     inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
 
     // LAYERING //
     void setLayer(E2D_LAYER layer);
-    void setLayer(const char* layer);
+    void setLayer(const std::string& layer);
     /** @returns the Layer this Element is drawn to */
     inline E2D_LAYER getLayer() const { return this->layer; };
@@ -121 +121 @@
     /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
     inline void setBindNode(const PNode* bindNode) { this->bindNode = bindNode; };
-    void setBindNode(const char* bindNode);
+    void setBindNode(const std::string& bindNode);
     inline const PNode* getBindNode() const { return this->bindNode; };
 
@@ -181 +181 @@
 
     void addChild2D (Element2D* child);
-    void addChild2D (const char* childName);
+    void addChild2D (const std::string& childName);
     void removeChild2D (Element2D* child);
     void remove2D();
@@ -187 +187 @@
     /** @param parent the new parent of this Element2D */
     void setParent2D (Element2D* parent) { parent->addChild2D(this); };
-    void setParent2D (const char* parentName);
+    void setParent2D (const std::string& parentName);
     /** @returns the parent of this Element2D */
     inline Element2D* getParent2D () const { return this->parent; };
@@ -194 +194 @@
 
     void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
-    void setParentSoft2D(const char* parentName, float bias = 1.0);
+    void setParentSoft2D(const std::string& parentName, float bias = 1.0);
 
     void setParentMode2D (E2D_PARENT_MODE parentMode);
-    void setParentMode2D (const char* parentingMode);
+    void setParentMode2D (const std::string& parentingMode);
     /** @returns the Parenting mode of this node */
     int getParentMode2D() const { return this->parentMode; };
@@ -213 +213 @@
     // helper functions //
     static const char* parentingModeToChar2D(int parentingMode);
-    static E2D_PARENT_MODE charToParentingMode2D(const char* parentingMode);
+    static E2D_PARENT_MODE charToParentingMode2D(const std::string& parentingMode);
 
     static const char* layer2DToChar(E2D_LAYER layer);
-    static E2D_LAYER charToLayer2D(const char* layer);
+    static E2D_LAYER charToLayer2D(const std::string& layer);
 
   private:

branches/std/src/lib/graphics/text_engine/text.cc

@@ -50 +50 @@
   if (this->font != NULL && this->font != Font::getDefaultFont())
     ResourceManager::getInstance()->unload(this->font);
-
-  if (this->text)
-    delete[] this->text;
 }
 
@@ -64 +61 @@
   // initialize this Text
   this->font = NULL;
-  this->text = NULL;
-  this->externText = NULL;
+  this->text = "";
   this->setAlignment(TEXT_DEFAULT_ALIGNMENT);
   this->blending = TEXT_DEFAULT_BLENDING;
   this->color = TEXT_DEFAULT_COLOR;
   this->setSize(TEXT_DEFAULT_SIZE);
-  this->setText(NULL);
+  this->setText("");
 }
 
@@ -104 +100 @@
  * @param text the new text to set
  */
-void Text::setText(const char* text, bool isExtern)
-{
-  if (isExtern)
-  {
-    this->externText = text;
-
-    if (unlikely(this->text != NULL))
-    {
-      delete[] this->text;
-      this->text = NULL;
-    }
-  }
-  else
-  {
-    this->externText = NULL;
-    if (this->text)
-      delete[] this->text;
-    if (text != NULL)
-    {
-      this->text = new char[strlen(text)+1];
-      strcpy(this->text, text);
-    }
-    else
-      this->text = NULL;
-  }
+void Text::setText(const std::string& text)
+{
+  this->text = text;
 
   // setting up the Text-Width if DYNAMIC
@@ -138 +112 @@
 
     float width = 0;
-    const char* tmpText = this->externText;
-    if (this->externText == NULL)
-      tmpText = this->text;
-    if (tmpText != NULL)
+    if (!this->text.empty())
     {
-      while (*tmpText != '\0')
+      for (unsigned int i = 0; i < this->text.size(); i++)
       {
-        if(glyphArray[*tmpText] != NULL)
+        if(glyphArray[this->text[i]] != NULL)
         {
-          width += glyphArray[*tmpText]->advance;
+          width += glyphArray[this->text[i]]->advance;
         }
-        tmpText++;
       }
       this->setSizeX2D(width *this->getSizeY2D());
@@ -190 +160 @@
     glBindTexture(GL_TEXTURE_2D, Font::getDefaultFont()->getTexture());
   }
-  const char* tmpText = this->externText;
-  if (this->externText == NULL)
-    tmpText = this->text;
-  if (likely(tmpText != NULL))
+  if (likely(!this->text.empty()))
   {
     glTranslatef(getAbsCoor2D().x, getAbsCoor2D().y, 0);
@@ -201 +168 @@
 
     glBegin(GL_QUADS);
-    while (likely(*tmpText != '\0'))
+    for (unsigned int i = 0; i < this->text.size(); i++)
     {
-      if(likely((tmpGlyph = glyphArray[*tmpText]) != NULL))
+      if(likely((tmpGlyph = glyphArray[this->text[i]]) != NULL))
       {
         glTexCoord2f(tmpGlyph->texCoord[1], tmpGlyph->texCoord[2]);
@@ -219 +186 @@
         posX += tmpGlyph->advance * this->getSizeY2D();
       }
-      ++tmpText;
     }
     glEnd();
@@ -232 +198 @@
 void Text::debug() const
 {
-  if (this->externText == NULL)
-    PRINT(0)("=== TEXT: %s ===\n", this->text);
-  else
-    PRINT(0)("=== TEXT: %s ===\n", this->externText);
+  PRINT(0)("=== TEXT: %s ===\n", this->text.c_str());
 
   if (this->getBindNode())

branches/std/src/lib/graphics/text_engine/text.h

@@ -45 +45 @@
     void setFont(const std::string& fontFile, unsigned int renderSize);
 
-    void setText(const char* text, bool isExtern = false);
+    void setText(const std::string& text);
 
     /** @returns the String this Text displays */
-    inline const char* getText() const { return (externText == NULL)?this->text:this->externText; };
+    inline const std::string& getText() const { return this->text; };
     /** @param blending the blending intensity to set (between 0.0 and 1.0) */
     inline void setBlending(float blending) { this->blending = blending; };
@@ -69 +69 @@
     Font*             font;           //!< Font of this text
 
-    char*             text;           //!< The text to display
-    const char*       externText;     //!< the text to Display from an external Source.
+    std::string       text;           //!< The text to display
     Vector            color;          //!< The color of the font.
     float             blending;       //!< The blending intensity.

branches/std/src/lib/lang/base_object.cc

@@ -95 +95 @@
 void BaseObject::setName (const std::string& objectName)
 {
-  printf("TEST\n");
   this->objectName = objectName;
-  printf("TEST2\n");
 }
 

branches/std/src/lib/lang/class_list.cc

@@ -37 +37 @@
  *  Creates a new ClassList
 */
-ClassList::ClassList(ClassID classID, unsigned long classIDFull, const char* className)
-{
-  this->className = className;
+ClassList::ClassList(ClassID classID, unsigned long classIDFull, const std::string& className)
+  : className(className)
+{
   this->classID = classID;
   this->classIDFull = classIDFull;
@@ -56 +56 @@
 
 //! a List of all strings of all classes, that have registered so far.
-std::list<const char*> ClassList::classNames;
+std::list<std::string> ClassList::classNames;
 
 /**
@@ -67 +67 @@
  * !! Before unsing the ClassList, as it creates the ClassLits
  */
-ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className)
+ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className)
 {
   if (unlikely(classList == NULL))
     ClassList::classList = new list<ClassList>();
 
-  PRINTF(5)("subscribe a '%s'\n", className );
+  PRINTF(5)("subscribe a '%s'\n", className.c_str() );
 
   ClassList* regClass = ClassList::getClassList(classID);
@@ -113 +113 @@
  * befor it changes anything.
  */
-const std::list<const char*>* ClassList::getClassNames()
+const std::list<std::string>* ClassList::getClassNames()
 {
   if (ClassList::classNames.size() != ClassList::classList->size())
@@ -155 +155 @@
  * @return the List accessed by classID, or NULL if not found
  */
-const std::list<BaseObject*>* ClassList::getList(const char* className)
+const std::list<BaseObject*>* ClassList::getList(const std::string& className)
 {
   ClassList* fl;
@@ -191 +191 @@
  * @returns the ClassList with className as specifyer, or NULL if not
  */
-ClassList* ClassList::getClassList(const char* className)
-{
-  if (className == NULL)
+ClassList* ClassList::getClassList(const std::string& className)
+{
+  if (className.empty())
     return NULL;
   std::list<ClassList>::iterator classIT = find (classList->begin(), classList->end(), className);
@@ -207 +207 @@
  * @todo: speed this up!!
  */
-BaseObject* ClassList::getObject(const char* objectName, ClassID classID)
+BaseObject* ClassList::getObject(const std::string& objectName, ClassID classID)
 {
   if (classID != CL_NULL)
@@ -216 +216 @@
       std::list<BaseObject*>::iterator bo;
       for (bo = cl->objectList.begin(); bo != cl->objectList.end(); bo++)
-        if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
+        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
           return (*bo);
     }
@@ -227 +227 @@
       std::list<BaseObject*>::iterator bo;
       for (bo = (*cl).objectList.begin(); bo != (*cl).objectList.end(); bo++)
-        if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
+        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
           return (*bo);
     }
@@ -276 +276 @@
     if (object->isA((*cl).classID))
   {
-    PRINT(0)("=%s::0x%.8X=-", (*cl).className, (*cl).classID);
+    PRINT(0)("=%s::0x%.8X=-", (*cl).className.c_str(), (*cl).classID);
   }
 }
@@ -285 +285 @@
  * @return a String containing the name of the Class, NULL if the Class was not found
  */
-const char* ClassList::IDToString(ClassID classID)
-{
+const std::string& ClassList::IDToString(ClassID classID)
+{
+  static const std::string empty("");
+
   ClassList* cl = ClassList::getClassList(classID);
-  return (cl != NULL) ? cl->className : NULL;
+  return (cl != NULL) ? cl->className : empty;
 }
 
@@ -296 +298 @@
  * @return the ClassID. CL_NULL, if the class was not found.
  */
-ClassID ClassList::StringToID(const char* className)
+ClassID ClassList::StringToID(const std::string& className)
 {
   ClassList* cl = ClassList::getClassList(className);
@@ -307 +309 @@
  * @returns true on match, false otherwise
  */
-bool ClassList::operator==(const char* className)
-{
-  if (likely( className != NULL && this->className != NULL))
-    return (!strcmp(this->className, className));
-  else
-    return false;
+bool ClassList::operator==(const std::string& className)
+{
+  return (this->className == className);
 }
 
@@ -342 +341 @@
       while (pow(10, lenCount) <= (*cl).objectList.size())
         ++lenCount;
-      for (int i=0; i < 30-strlen((*cl).className) - lenCount; i++)
+      for (int i=0; i < 30-(*cl).className.size() - lenCount; i++)
         (niceString[i]) = ' ';
-      niceString[30-strlen((*cl).className) - lenCount] = '\0';
-
-      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className, niceString, (*cl).objectList.size());
+      niceString[30-(*cl).className.size() - lenCount] = '\0';
+
+      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className.c_str(), niceString, (*cl).objectList.size());
 
       if (debugLevel >=2 && (*cl).objectList.size() > 0)
@@ -371 +370 @@
  * @see ClassList::debug
  */
-void ClassList::debugS(const char* className, unsigned int debugLevel)
+void ClassList::debugS(const std::string& className, unsigned int debugLevel)
 {
   ClassList::debug(debugLevel, ClassList::StringToID(className));

branches/std/src/lib/lang/class_list.h

@@ -10 +10 @@
 #include "class_id.h"
 #include <list>
+#include <string>
 #ifndef NULL
 #define NULL     0    //!< NULL
@@ -32 +33 @@
 class ClassList {
   public:
-    ClassList(ClassID classID, unsigned long classIDFull, const char* className);
+    ClassList(ClassID classID, unsigned long classIDFull, const std::string& className);
     virtual ~ClassList();
 
     /* MAINTENANCE FUNCTIONS THESE ARE !!ONLY FOR BASEOBJECT !! */
-    static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className);
+    static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className);
     static void                           removeFromClassList(BaseObject* objectPointer);
 
@@ -42 +43 @@
 
     static const std::list<BaseObject*>*  getList(ClassID classID = CL_NULL);// { return (ClassList* fl = ClassList::getClassList(classID) != NULL)? &(fl->objectList) : NULL; };
-    static const std::list<BaseObject*>*  getList(const char* className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
-    static const std::list<const char*>*  getClassNames();
-    static BaseObject*                    getObject(const char* name, ClassID classID = CL_NULL);
+    static const std::list<BaseObject*>*  getList(const std::string& className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
+    static const std::list<std::string>*  getClassNames();
+    static BaseObject*                    getObject(const std::string& name, ClassID classID = CL_NULL);
     static bool                           exists(const BaseObject* object, ClassID classID = CL_NULL);
 
@@ -51 +52 @@
     static void                           whatIs(const BaseObject* object);
 
-    static const char*                    IDToString(ClassID classID = CL_NULL);
-    static ClassID                        StringToID(const char* className);
+    static const std::string&             IDToString(ClassID classID = CL_NULL);
+    static ClassID                        StringToID(const std::string& className);
     static void                           debug(unsigned int debugLevel = 0, ClassID classID = CL_NULL);
-    static void                           debugS(const char* className = NULL, unsigned int debugLevel = 0);
+    static void                           debugS(const std::string& className = "", unsigned int debugLevel = 0);
 
     inline bool                           operator==(ClassID classID) { return (this->classID == classID); };
-    bool                                  operator==(const char* className);
+    bool                                  operator==(const std::string& className);
     inline ClassID                        getLeafClassID() const { return this->classID; };
 
   private:
     static ClassList*                     getClassList(ClassID classID);
-    static ClassList*                     getClassList(const char* className);
+    static ClassList*                     getClassList(const std::string& className);
 
   private:
-    ClassID                         classID;                //!< ClassID stored in this ClassList
-    unsigned long                   classIDFull;            //!< The Full ClassID of this Class.
+    ClassID                               classID;                //!< ClassID stored in this ClassList
+    unsigned long                         classIDFull;            //!< The Full ClassID of this Class.
 
-    const char*                     className;              //!< Name of the Class Stored here
+    const std::string                     className;              //!< Name of the Class Stored here
 
-    std::list<BaseObject*>          objectList;             //!< A list of Objects belonging to this Class
+    std::list<BaseObject*>                objectList;             //!< A list of Objects belonging to this Class
 
     // STATIC MEMBERS
-    static std::list<ClassList>*    classList;              //!< The first Class in the List
-    static std::list<const char*>   classNames;             //!< a List of all Names of all classes, that have registered so far.
+    static std::list<ClassList>*          classList;              //!< The first Class in the List
+    static std::list<std::string>         classNames;             //!< a List of all Names of all classes, that have registered so far.
 };
 

branches/std/src/lib/particles/dot_particles.h

@@ -21 +21 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */

branches/std/src/lib/particles/model_particles.cc

@@ -89 +89 @@
  * @param textureFile the Texture to load onto these ModelParticles
  */
-void ModelParticles::setMaterialTexture(const char* textureFile)
+void ModelParticles::setMaterialTexture(const std::string& textureFile)
 {
   this->material.setDiffuseMap(textureFile);

branches/std/src/lib/particles/model_particles.h

@@ -20 +20 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */

branches/std/src/lib/particles/sprite_particles.cc

@@ -89 +89 @@
  * @param textureFile the Texture to load onto these SpriteParticles
  */
-void SpriteParticles::setMaterialTexture(const char* textureFile)
+void SpriteParticles::setMaterialTexture(const std::string& textureFile)
 {
   this->material.setDiffuseMap(textureFile);

branches/std/src/lib/particles/sprite_particles.h

@@ -21 +21 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */

branches/std/src/lib/physics/physics_connection.cc

@@ -73 +73 @@
  * @param subjectName the name of the Subject for this PhysicsConnection
 */
-void PhysicsConnection::setSubject(const char* subjectName)
+void PhysicsConnection::setSubject(const std::string& subjectName)
 {
   this->subject = PhysicsEngine::getInstance()->getPhysicsInterfaceByName(subjectName);
   if (this->subject == NULL)
   {
-    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName);
+    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName.c_str());
   }
   else
@@ -87 +87 @@
 * @param fieldName the Name of the Field for this connection
 */
-void PhysicsConnection::setField(const char* fieldName)
+void PhysicsConnection::setField(const std::string& fieldName)
 {
   this->field = PhysicsEngine::getInstance()->getFieldByName(fieldName);
   if (this->field == NULL)
   {
-        PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName);
+    PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName.c_str());
   }
   else

branches/std/src/lib/physics/physics_connection.h

@@ -35 +35 @@
   virtual ~PhysicsConnection();
 
-  void setSubject(const char* subjectName);
-  void setField(const char* fieldName);
+  void setSubject(const std::string& subjectName);
+  void setField(const std::string& fieldName);
 
   void apply() const;

branches/std/src/lib/physics/physics_engine.cc

@@ -128 +128 @@
   @returns the PhysicsInterface if found, or NULL if not
  */
-PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
+PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const
 {
   BaseObject* interface = ClassList::getObject(physicsInterfaceName, CL_PHYSICS_INTERFACE);
@@ -157 +157 @@
 
 /**
-* @param FieldName the Name of the PhysicsInterface to search for
+* @param fieldName the Name of the PhysicsInterface to search for
   @returns the Field if found, or NULL if not
  */
-Field* PhysicsEngine::getFieldByName(const char* FieldName) const
+Field* PhysicsEngine::getFieldByName(const std::string& fieldName) const
 {
   list<Field*>::const_iterator field;
   for (field = this->fields.begin(); field != this->fields.end(); field++)
-    if (!strcmp(FieldName, (*field)->getName()))
+    if (fieldName == (*field)->getName())
       return (*field);
   return NULL;
@@ -197 +197 @@
   @returns the PhysicsConnection if found, or NULL if not
  */
-PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const char* physicsConnectionName) const
+PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const std::string& physicsConnectionName) const
 {
   list<PhysicsConnection*>::const_iterator pc;
   for (pc = this->connections.begin(); pc != this->connections.end(); pc++)
-    if (!strcmp(physicsConnectionName, (*pc)->getName()))
+    if (physicsConnectionName == (*pc)->getName())
       delete (*pc);
   return NULL;

branches/std/src/lib/physics/physics_engine.h

@@ -31 +31 @@
   void loadConnections(const TiXmlElement* root);
 
-  PhysicsInterface*      getPhysicsInterfaceByName(const char* physicsInterfaceName) const;
+  PhysicsInterface*      getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const;
 
   void                   addField(Field* field);
   void                   removeField(Field* field);
-  Field*                 getFieldByName(const char* FieldName) const;
+  Field*                 getFieldByName(const std::string& fieldName) const;
 
   void                   addConnection(PhysicsConnection* connection);
   void                   removeConnection(PhysicsConnection* connection);
-  PhysicsConnection*     getPhysicsConnectionByName(const char* physicsConnectionName) const;
+  PhysicsConnection*     getPhysicsConnectionByName(const std::string& physicsConnectionName) const;
 
 

branches/std/src/lib/shell/shell.cc

@@ -85 +85 @@
   this->lineSpacing = 0;
   this->bActive = true;
-  this->fontFile = new char[strlen(SHELL_DEFAULT_FONT)+1];
-  strcpy(this->fontFile, SHELL_DEFAULT_FONT);
+  this->fontFile = SHELL_DEFAULT_FONT;
 
 
@@ -110 +109 @@
     delete this->bufferText[i];
   delete[] this->bufferText;
-  delete[] this->fontFile;
   // delete the inputLine
   delete this->shellInput;
@@ -139 +137 @@
     if (!top)
     {
-      this->bufferText[i]->setText((*textLine), true);
+      this->bufferText[i]->setText((*textLine));
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
       top = true;
@@ -167 +165 @@
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
     {
-      this->bufferText[i]->setText((*textLine), false);
+      this->bufferText[i]->setText((*textLine));
       textLine--;
     }
@@ -181 +179 @@
  * (be aware that within orxonox fontFile is relative to the Data-Dir)
  */
-void Shell::setFont(const char* fontFile)
+void Shell::setFont(const std::string& fontFile)
 {
 //   if (!ResourceManager::isInDataDir(fontFile))
 //     return false;
 
-  if (this->fontFile != NULL)
-    delete[] this->fontFile;
-
-  this->fontFile = new char[strlen(fontFile)+1];
-  strcpy(this->fontFile, fontFile);
+  this->fontFile = fontFile;
 
   this->rebuildText();
@@ -245 +239 @@
  * @param fileName the filename of the Image to load
  */
-void Shell::setBackgroundImage(const char* fileName)
+void Shell::setBackgroundImage(const std::string& fileName)
 {
   this->backgroundMaterial->setDiffuseMap(fileName);
@@ -340 +334 @@
     for (int i = 0; i < this->bufferDisplaySize; i++)
     {
-      this->bufferText[i]->setText(NULL, true);
+      this->bufferText[i]->setText("");
     }
 
@@ -351 +345 @@
  * @param text the text to output.
  */
-void Shell::printToDisplayBuffer(const char* text)
+void Shell::printToDisplayBuffer(const std::string& text)
 {
   if(likely(bufferText != NULL))
@@ -382 +376 @@
     this->bufferText[0] = lastText;
 
-    this->bufferText[0]->setText(text, true);
+    this->bufferText[0]->setText(text);
   }
 }
@@ -427 +421 @@
   for (unsigned int i = 0; i < this->bufferDisplaySize; i++)
   {
-    this->bufferText[i]->setText((*it), false);
+    this->bufferText[i]->setText((*it));
     it--;
   }

branches/std/src/lib/shell/shell.h

@@ -53 +53 @@
     inline bool isActive() const { return this->bActive; };
 
-    void setFont(const char* fontFile);
+    void setFont(const std::string& fontFile);
     void setTextSize(unsigned int textSize, unsigned int lineSpacing = 1);
     void setTextColor(float r, float g, float b, float a);
     void setBackgroundColor(float r, float g, float b, float a);
-    void setBackgroundImage(const char* fileName);
+    void setBackgroundImage(const std::string& fileName);
 
     void resetValues();
@@ -64 +64 @@
     // BUFFERS
     void setBufferDisplaySize(unsigned int bufferDisplaySize);
-    void printToDisplayBuffer(const char* text);
+    void printToDisplayBuffer(const std::string& text);
     void moveDisplayBuffer(int lineCount);
 
@@ -83 +83 @@
 
     //     void testI (int i);
-    //     void testS (const char* s);
+    //     void testS (const std::string& s);
     //     void testB (bool b);
     //     void testF (float f);
-    //     void testSF (const char* s, float f);
+    //     void testSF (const std::string& s, float f);
 
   private:
@@ -95 +95 @@
     unsigned int                textSize;               //!< The size of the text.
     float                       textColor[4];           //!< The text's color [r,g,b,a].
-    char*                       fontFile;               //!< The file containing the font.
+    std::string                 fontFile;               //!< The file containing the font.
     Material*                   backgroundMaterial;     //!< A material for the background.
 

branches/std/src/lib/shell/shell_command.cc

@@ -153 +153 @@
  * @return true on success, false otherwise.
  */
-bool ShellCommand::execute(const char* executionString)
+bool ShellCommand::execute(const std::string& executionString)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -184 +184 @@
           {
             if (inputSplits.getCount() > 1)
-              (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
+            {
+
+              (*alias)->getCommand()->executor->execute(objectList->front(), executionString.substr(inputSplits.getOffset(1), executionString.size())); /// TODO CHECK IF OK
+            }
             else
               (*alias)->getCommand()->executor->execute(objectList->front(), "");
@@ -240 +243 @@
               return false;
             if (inputSplits.getCount() > fktPos+1)
-              (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
+              (*cmdIT)->executor->execute(objectPointer, executionString.substr(inputSplits.getOffset(fktPos +1), executionString.size())); /// TODO CHECK IF OK
             else
               (*cmdIT)->executor->execute(objectPointer, "");
@@ -326 +329 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
 
     list<ShellCommand*>::iterator cmdIT;

branches/std/src/lib/shell/shell_command.h

@@ -61 +61 @@
   friend class ShellCommandClass;
   public:
-    static bool execute (const char* executionString);
+    static bool execute (const std::string& executionString);
 
     ShellCommand* describe(const char* description);

branches/std/src/lib/shell/shell_command_class.cc

@@ -36 +36 @@
  * @param className the Name of the command-class to create
  */
-ShellCommandClass::ShellCommandClass(const char* className)
+ShellCommandClass::ShellCommandClass(const std::string& className)
+  : className(className)
 {
   this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
   this->setName(className);
 
-  this->className = className;
   this->classID = CL_NULL;
 
@@ -65 +65 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
-{
-  if (stringList == NULL || className == NULL)
+bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>* stringList)
+{
+  if (stringList == NULL)
     return false;
 
@@ -73 +73 @@
   for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
   {
-    if (!strcmp ((*elem)->getName(), className))
+    if (className == (*elem)->getName())
     {
       list<ShellCommand*>::iterator command;
@@ -88 +88 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
+bool ShellCommandClass::getCommandListOfAlias(std::list<std::string>* stringList)
 {
   if (stringList == NULL || ShellCommandClass::aliasList == NULL)
@@ -138 +138 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       if ((*classIT)->classID == CL_NULL)
@@ -154 +154 @@
  * @returns the CommandClass if found, or a new CommandClass if not
  */
-ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
+ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -162 +162 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       return (*classIT);
@@ -186 +186 @@
  * @param className: the Class of Commands to show help about
  */
-void ShellCommandClass::help(const char* className)
-{
-  if (className == NULL)
-    return;
+void ShellCommandClass::help(const std::string& className)
+{
   if (likely(ShellCommandClass::commandClassList != NULL))
   {
@@ -195 +193 @@
     for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
     {
-      if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
+      if (className == (*classIT)->className)
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
         list<ShellCommand*>::const_iterator cmdIT;
         for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
@@ -212 +210 @@
       }
     }
-    PRINTF(3)("Class %s not found in Command's classes\n", className);
+    PRINTF(3)("Class %s not found in Command's classes\n", className.c_str());
   }
   else

branches/std/src/lib/shell/shell_command_class.h

@@ -27 +27 @@
     /** @returns the CommandClassList */
     static const std::list<ShellCommandClass*>* getCommandClassList() { return ShellCommandClass::commandClassList; };
-    static bool getCommandListOfClass(const char* className, std::list<const char*>* stringList);
-    static bool getCommandListOfAlias(std::list<const char*>* aliasList);
+    static bool getCommandListOfClass(const std::string& className, std::list<std::string>* stringList);
+    static bool getCommandListOfAlias(std::list<std::string>* aliasList);
 
-    static ShellCommandClass* getCommandClass(const char* className);
+    static ShellCommandClass* getCommandClass(const std::string& className);
     static void unregisterAllCommands();
 
-    static void help (const char* className);
+    static void help (const std::string& className);
 
   private:
-    ShellCommandClass(const char* className);
+    ShellCommandClass(const std::string& className);
     virtual ~ShellCommandClass();
 
@@ -43 +43 @@
 
   private:
-    const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    const std::string                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     long                                   classID;                   //!< The classID of this Class
     std::list<ShellCommand*>               commandList;               //!< A list of Commands from this Class

branches/std/src/lib/shell/shell_completion.cc

@@ -76 +76 @@
 
   // Check if we are in a input. eg. the supplied string "class " and now we complete either function or object
-  if (this->input->getInput() != NULL &&
-      strrchr(this->input->getInput(), ' ') >= this->input->getInput() + strlen(this->input->getInput())-1)
+  if (this->input->getInput()[this->input->getInput().size()-1] == ' ')
   {
     emptyComplete = true;
@@ -83 +82 @@
 
   // CREATE INPUTS
-  if (this->input->getInput() == NULL)
-    completionLine = "";
-  else
-    completionLine = this->input->getInput() + strspn(this->input->getInput(), " \t\n");
-  SubString inputSplits(completionLine, " \t\n,");
+  SubString inputSplits(this->input->getInput(), " \t\n,");
 
   // What String will be completed
@@ -151 +146 @@
   if (unlikely(classBegin == NULL))
     return false;
-  const std::list<const char*>* clList = ClassList::getClassNames();
+  const std::list<std::string>* clList = ClassList::getClassNames();
   if (clList != NULL)
   {
@@ -195 +190 @@
   if (unlikely(functionBegin == NULL))
     return false;
-  std::list<const char*> fktList;
+  std::list<std::string> fktList;
   ShellCommandClass::getCommandListOfClass(className, &fktList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -212 +207 @@
   if (unlikely(aliasBegin == NULL))
     return false;
-  std::list<const char*> aliasList;
+  std::list<std::string> aliasList;
   ShellCommandClass::getCommandListOfAlias(&aliasList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -295 +290 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -301 +296 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  list<const char*>::const_iterator string;
+  list<std::string>::const_iterator string;
   for (string = inputList->begin(); string != inputList->end(); string++)
   {
-    if (strlen(*string) >= searchLength &&
-        !strncasecmp(*string, completionBegin, searchLength))
+    if ((*string).size() >= searchLength &&
+          !strncasecmp((*string).c_str(), completionBegin, searchLength))
     {
       ShellC_Element newElem;
-      newElem.name = *string;
+      newElem.name = (*string).c_str();
       newElem.type = type;
       this->completionList.push_back(newElem);

branches/std/src/lib/shell/shell_completion.h

@@ -52 +52 @@
   bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
 
-  bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type);
   bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
   void emptyCompletionList();

branches/std/src/lib/shell/shell_input.cc

@@ -46 +46 @@
   this->setClassID(CL_SHELL_INPUT, "ShellInput");
 
-  this->inputLine = new char[1];
-  this->inputLine[0] = '\0';
+  this->inputLine = "";
   this->historyIT = this->history.begin();
   this->setHistoryLength(50);
@@ -70 +69 @@
 {
   // delete what has to be deleted here
-  delete[] this->inputLine;
   delete this->completion;
 
   while (!this->history.empty())
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -96 +93 @@
 void ShellInput::flush()
 {
-  if (likely(this->inputLine != NULL))
-  {
-    delete[] this->inputLine;
-  }
-  this->inputLine = new char[1];
-  *this->inputLine = '\0';
-  this->setText(this->inputLine, true);
+  this->inputLine.clear();
+  this->setText(this->inputLine);
 }
 
@@ -109 +101 @@
  * @param text the new Text to set as InputLine
  */
-void ShellInput::setInputText(const char* text)
-{
-  delete[] this->inputLine;
-  if (text == NULL)
-  {
-    this->inputLine = new char[1];
-    this->inputLine[0] = '\0';
-  }
-  else
-  {
-    this->inputLine = new char[strlen(text)+1];
-    strcpy(this->inputLine, text);
-  }
-  this->setText(this->inputLine, true);
+void ShellInput::setInputText(const std::string& text)
+{
+  this->inputLine = text;
+  this->setText(this->inputLine);
 }
 
@@ -134 +116 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+2];
-
-  sprintf(addCharLine, "%s%c", this->inputLine, character);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += character;
+  this->setText(this->inputLine);
 }
 
@@ -151 +128 @@
  * @param characters a \\0 terminated char-array to add to the InputLine
  */
-void ShellInput::addCharacters(const char* characters)
+void ShellInput::addCharacters(const std::string& characters)
 {
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+strlen(characters)+1];
-
-  sprintf(addCharLine, "%s%s", this->inputLine, characters);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += characters;
+  this->setText(this->inputLine);
 }
 
@@ -176 +148 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
-
-  if (strlen(this->inputLine) == 0)
-    return;
-
-  if (characterCount > strlen(this->inputLine))
-    characterCount = strlen(this->inputLine);
-
-  char* removeCharLine = new char[strlen(this->inputLine)-characterCount+1];
-
-  strncpy(removeCharLine, this->inputLine, strlen(this->inputLine)-characterCount);
-  removeCharLine[strlen(this->inputLine)-characterCount] = '\0';
-  delete[] this->inputLine;
-  this->inputLine = removeCharLine;
-  this->setText(this->inputLine, true);
+  if (this->inputLine.size() < characterCount)
+    characterCount = this->inputLine.size();
+
+  this->inputLine.erase(this->inputLine.size() - characterCount, this->inputLine.size());
+  this->setText(this->inputLine);
 }
 
@@ -202 +164 @@
 bool ShellInput::executeCommand()
 {
-  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine);
-
-  if (strlen(this->inputLine) == 0)
+  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine.c_str());
+
+  if (this->inputLine.empty())
     return false;
 
-  char* newCommand = new char[strlen(this->inputLine)+1];
-  strcpy(newCommand, this->inputLine);
-
-  ShellCommand::execute(newCommand);
+  ShellCommand::execute(this->inputLine);
 
   // removing the eventually added Entry (from scrolling) to the List
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
@@ -221 +179 @@
 
   // adding the new Command to the History
-  this->history.push_back(newCommand);
+  this->history.push_back(this->inputLine);
   if (this->history.size() > this->historyLength)
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -241 +198 @@
   if (!this->historyScrolling)
   {
-    char* currentText = new char[strlen(this->inputLine)+1];
-    strcpy(currentText, this->inputLine);
-    this->history.push_back(currentText);
+    this->history.push_back(this->inputLine);
     this->historyScrolling = true;
     this->historyIT = --this->history.end();
@@ -250 +205 @@
   if(this->historyIT != this->history.begin())
   {
-    char* prevElem = *(--this->historyIT);
-    if (prevElem == NULL)
+    std::string prevElem = *(--this->historyIT);
+    /*if (prevElem == NULL) /// TODO STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -270 +225 @@
   if (this->historyIT != this->history.end())
   {
-    char* nextElem = *(++this->historyIT);
-    if (nextElem == NULL)
+    std::string nextElem = *(++this->historyIT);
+    /*    if (nextElem == NULL) /// TODO FIX STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -285 +240 @@
  * prints out some nice help about the Shell
  */
-void ShellInput::help(const char* className, const char* functionName)
-{
-  printf("%s::%s\n", className, functionName);
-
-  if (strlen(className) == 0)
+void ShellInput::help(const std::string& className, const std::string& functionName)
+{
+  printf("%s::%s\n", className.c_str(), functionName.c_str());
+
+  if (className.empty())
   {
     PRINT(0)("Help for the most important Shell-commands\n");
@@ -298 +253 @@
     PRINT(0)("- Also try 'help className'");
   }
-  else if (strlen (className) > 0 && strlen (functionName) == 0)
+  else if (!className.empty() && functionName.empty())
   {
     ShellCommandClass::help(className);

branches/std/src/lib/shell/shell_input.h

@@ -31 +31 @@
 
   /** @returns the inputLine */
-  const char* getInput() const { return this->inputLine; };
+  const std::string& getInput() const { return this->inputLine; };
 
   // InputLine
   void flush();
-  void setInputText(const char* text);
+  void setInputText(const std::string& text);
   void addCharacter(char character);
-  void addCharacters(const char* characters);
+  void addCharacters(const std::string& characters);
   void removeCharacters(unsigned int characterCount = 1);
   void setRepeatDelay(float repeatDelay, float repeatRate);
@@ -47 +47 @@
   void historyMoveDown();
 
-  void help(const char* className = "", const char* function = "");
+  void help(const std::string& className = "", const std::string& function = "");
 
   virtual void tick(float dt);
@@ -54 +54 @@
  private:
     // HANDLING TEXT INPUT
-   ShellCompletion*            completion;             //!< The Completion Interface.
+   ShellCompletion*                  completion;       //!< The Completion Interface.
 
-   char*                       inputLine;              //!< the Char-Array of the Buffer
-   float                       repeatRate;             //!< The Repeat-Delay.
-   float                       repeatDelay;            //!< The delay of the first Character of a given Character.
-   float                       delayed;                //!< how much of the delay is remaining.
-   Uint16                      pressedKey;             //!< the pressed key that will be repeated.
+   std::string                       inputLine;        //!< the Char-Array of the Buffer
+   float                             repeatRate;       //!< The Repeat-Delay.
+   float                             repeatDelay;      //!< The delay of the first Character of a given Character.
+   float                             delayed;          //!< how much of the delay is remaining.
+   Uint16                            pressedKey;       //!< the pressed key that will be repeated.
 
-   std::list<char*>            history;                //!< The history of given commands.
-   std::list<char*>::iterator  historyIT;
-   unsigned int                historyLength;          //!< The maximum length of the InputHistory.
-   bool                        historyScrolling;       //!< true if we are scrolling through the history.
+   std::list<std::string>            history;          //!< The history of given commands.
+   std::list<std::string>::iterator  historyIT;        //!< The locator that tells us, where we are in the history.
+   unsigned int                      historyLength;    //!< The maximum length of the InputHistory.
+   bool                              historyScrolling; //!< true if we are scrolling through the history.
 };
 

branches/std/src/lib/util/executor/executor.h

@@ -271 +271 @@
     {
       SubString sub;
-      printf("===%s\n", parameters.c_str());
       sub.split(parameters, " \n\t,", '\\');
-      sub.debug();
 //! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ExecutorExecute ## x

branches/std/src/lib/util/executor/functor_list.h

@@ -98 +98 @@
 
   FUNCTOR_LIST(0)();
-  //! makes functions with one cstring
-  FUNCTOR_LIST(1)(l_CSTRING);
-  //! makes functions with two cstrings
-  FUNCTOR_LIST(2)(l_CSTRING, l_CSTRING);
-  //! makes functions with three cstrings
-  FUNCTOR_LIST(3)(l_CSTRING, l_CSTRING, l_CSTRING);
-  //! makes functions with four cstrings
-  FUNCTOR_LIST(4)(l_CSTRING, l_CSTRING, l_CSTRING, l_CSTRING);
-
   //! makes functions with one string
   FUNCTOR_LIST(1)(l_STRING);
@@ -151 +142 @@
 
   //! mixed values:
-  FUNCTOR_LIST(2)(l_CSTRING, l_FLOAT);
+  FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
   FUNCTOR_LIST(2)(l_UINT, l_LONG);
-  FUNCTOR_LIST(2)(l_CSTRING, l_UINT);
+  FUNCTOR_LIST(2)(l_STRING, l_UINT);
 
-  FUNCTOR_LIST(3)(l_CSTRING, l_FLOAT, l_UINT);
+  FUNCTOR_LIST(3)(l_STRING, l_FLOAT, l_UINT);
 
 

branches/std/src/lib/util/helper_functions.cc

@@ -104 +104 @@
 {
   if (STRING.size() > 0)
-  {
-    printf("DECISION1: %s\n", STRING.c_str());
     return STRING;
-  }
   else
-  {
-    printf("DECISION2: %s\n", defaultValue.c_str());
     return defaultValue;
-  }
 }
 

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

@@ -66 +66 @@
           ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
     {
-      PRINTF(0)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
+      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
       this->executor->execute(this->object, loadString);
     }