Index: branches/std/src/lib/graphics/graphics_engine.cc
===================================================================
--- branches/std/src/lib/graphics/graphics_engine.cc	(revision 7210)
+++ branches/std/src/lib/graphics/graphics_engine.cc	(revision 7211)
@@ -176,5 +176,5 @@
   const std::string textures = iniParser->getVar(CONFIG_NAME_TEXTURES, CONFIG_SECTION_VIDEO_ADVANCED, "0");
   if (textures[0] == '1' || textures == "true")
-    Texture::setTextureEnableState( true);
+    Texture::setTextureEnableState(true);
   else
     Texture::setTextureEnableState(false);
@@ -183,6 +183,6 @@
   SubString resolution(iniParser->getVar(CONFIG_NAME_RESOLUTION, CONFIG_SECTION_VIDEO, "640x480").c_str(), 'x'); ///FIXME
   //resolution.debug();
-
-  this->initVideo(atoi(resolution.getString(0)), atoi(resolution.getString(1)), 16);
+  MultiType x = resolution.getString(0), y = resolution.getString(1);
+  this->initVideo(x.getInt(), y.getInt(), 16);
 
   //   GraphicsEffect* fe = new FogEffect(NULL);
@@ -533,5 +533,5 @@
   if (this->hwExtensions != NULL)
     for (unsigned int i = 0; i < this->hwExtensions->getCount(); i++)
-      if (!strcmp(extension, this->hwExtensions->getString(i)))
+      if ( this->hwExtensions->getString(i) == extension)
         return true;
   return false;
Index: branches/std/src/lib/shell/shell_command.cc
===================================================================
--- branches/std/src/lib/shell/shell_command.cc	(revision 7210)
+++ branches/std/src/lib/shell/shell_command.cc	(revision 7211)
@@ -177,5 +177,5 @@
       for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++ )
       {
-        if ((*alias)->getName() != NULL && !strcmp((*alias)->getName(), inputSplits.getString(0)) && (*alias)->getCommand() != NULL &&
+        if ((*alias)->getName() != NULL && inputSplits.getString(0) == (*alias)->getName() && (*alias)->getCommand() != NULL &&
             (*alias)->getCommand()->shellClass != NULL )
         {
@@ -198,5 +198,5 @@
       for (commandClassIT = ShellCommandClass::commandClassList->begin(); commandClassIT != ShellCommandClass::commandClassList->end(); commandClassIT++)
       {
-        if ((*commandClassIT)->getName() && !strcasecmp(inputSplits.getString(0), (*commandClassIT)->getName()))
+        if ((*commandClassIT)->getName() && inputSplits.getString(0) == (*commandClassIT)->getName())
         {
           //elemCL->getName();
@@ -217,5 +217,5 @@
         for (object = objectList->begin(); object != objectList->end(); object++)
         {
-          if ((*object)->getName() != NULL && !strcasecmp((*object)->getName(), inputSplits.getString(1)))
+          if ((*object)->getName() != NULL && inputSplits.getString(1) == (*object)->getName() )
           {
             objectPointer = (*object);
@@ -235,5 +235,5 @@
         for (cmdIT = commandClass->commandList.begin(); cmdIT != commandClass->commandList.end(); cmdIT++)
         {
-          if (!strcmp((*cmdIT)->getName(), inputSplits.getString(fktPos)))
+          if (inputSplits.getString(fktPos) == (*cmdIT)->getName())
           {
             if (objectPointer == NULL && (*cmdIT)->executor->getType() & Executor_Objective)
Index: branches/std/src/lib/shell/shell_completion.cc
===================================================================
--- branches/std/src/lib/shell/shell_completion.cc	(revision 7210)
+++ branches/std/src/lib/shell/shell_completion.cc	(revision 7211)
@@ -93,5 +93,5 @@
     completeString = "";
   else
-    completeString = inputSplits.getString(inputSplits.getCount()-1);
+    completeString = inputSplits.getString(inputSplits.getCount()-1).c_str();
 
   // CLASS COMPLETION
@@ -111,5 +111,5 @@
             (inputSplits.getCount() == 2 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0).c_str()); //FIXME
     objectList = ClassList::getList((ClassID)classID);
     if (classID != CL_NULL)
@@ -121,5 +121,5 @@
             (inputSplits.getCount() == 3 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0) .c_str()); // FIXME
     if (classID == CL_NULL)
       return false;
@@ -133,5 +133,5 @@
     this->objectComplete(completeString, classID);
   if (completeType & SHELLC_FUNCTION)
-    this->functionComplete(completeString, inputSplits.getString(0));
+    this->functionComplete(completeString, inputSplits.getString(0).c_str()); // FIXME
   if (completeType & SHELLC_ALIAS)
     this->aliasComplete(completeString);
Index: branches/std/src/lib/util/executor/executor.h
===================================================================
--- branches/std/src/lib/util/executor/executor.h	(revision 7210)
+++ branches/std/src/lib/util/executor/executor.h	(revision 7211)
@@ -16,8 +16,8 @@
 //! an enumerator for the definition of the Type.
 typedef enum {
-  Executor_Objective         = 0x00000001,
-  Executor_Static            = 0x00000002,
-
-  Executor_NoLoadString      = 0x00000010,
+  Executor_Objective         = 1,
+  Executor_Static            = 2,
+
+  Executor_NoLoadString      = 8,
 } Executor_Type;
 
@@ -192,5 +192,5 @@
 #define ExecutorExecute1(t1) \
    else if (this->paramCount == 1 && this->defaultValue[0] == t1##_PARAM) \
-    EXECUTOREXECUTER(_1_##t1)(t1##_FUNC((const char*)parameters, t1##_DEFGRAB(0)))
+    EXECUTOREXECUTER(_1_##t1)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)))
 
 //! execute-macro for functions with two parameters
@@ -270,5 +270,5 @@
     virtual void execute (BaseObject* object, const void* parameters = NULL)
     {
-      SubString sub(((const std::string*) parameters)->c_str(), " \n\t,", '\\');
+      SubString sub((const char*)parameters, " \n\t", '\\');
 //! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ExecutorExecute ## x
@@ -332,5 +332,5 @@
     virtual void execute (BaseObject* object, const void* parameters = NULL)
     {
-  SubString sub((const char*)parameters, " \n\t,");
+      SubString sub(((const char*)parameters), " \n\t,");
 //! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ExecutorExecute ## x
Index: branches/std/src/lib/util/helper_functions.cc
===================================================================
--- branches/std/src/lib/util/helper_functions.cc	(revision 7210)
+++ branches/std/src/lib/util/helper_functions.cc	(revision 7211)
@@ -27,15 +27,14 @@
  * @return returns the bool, if BOOL was correct otherwise defaultValue
  */
-bool isBool(const char* BOOL, bool defaultValue)
+bool isBool(const std::string& BOOL, bool defaultValue)
 {
-  if (BOOL == NULL)
+  if (BOOL.empty())
     return defaultValue;
-  if(!strcmp(BOOL, "1") || !strcasecmp( BOOL, "true") )
+  if(BOOL[0] == '1' || BOOL == "true" )
     return true;
-  else if (!strcmp(BOOL, "0") || !strcasecmp( BOOL, "false"))
+  else if (BOOL[0] == '0' || BOOL == "false")
     return false;
   else
     return defaultValue;
-
 }
 
@@ -47,13 +46,13 @@
  * @return returns the contained int, if INT was correct otherwise defaultValue
  */
-int isInt(const char* INT, int defaultValue)
+int isInt(const std::string& INT, int defaultValue)
 {
-  if (INT == NULL)
+  if (INT.empty())
     return defaultValue;
   char* endPtr = NULL;
 
-  int result = strtol(INT, &endPtr, 10);
+  int result = strtol(INT.c_str(), &endPtr, 10);
 
-  if ( endPtr >= INT && endPtr < INT + strlen(INT))
+  if ( endPtr >= INT.c_str() && endPtr < INT.c_str()+ INT.size())
     return defaultValue;
   else
@@ -68,12 +67,12 @@
  * @return returns the contained float, if FLOAT was correct otherwise defaultValue
  */
-float isFloat(const char* FLOAT, float defaultValue)
+float isFloat(const std::string& FLOAT, float defaultValue)
 {
-  if (FLOAT == NULL)
+  if (FLOAT.empty())
     return defaultValue;
   char* endPtr = NULL;
-  double result = strtod(FLOAT, &endPtr);
+  double result = strtod(FLOAT.c_str(), &endPtr);
 
-  if ( endPtr >= FLOAT && endPtr < FLOAT + strlen(FLOAT))
+  if ( endPtr >= FLOAT.c_str() && endPtr < FLOAT.c_str() + FLOAT.size())
     return defaultValue;
   else
@@ -88,8 +87,8 @@
  * @return returns the contained string (char-array), if STRING was correct otherwise defaultValue
  */
-const char* isCString(const char* STRING, const char* defaultValue)
+const char* isCString(const std::string& STRING, const char* defaultValue)
 {
-  if (STRING != NULL && strlen(STRING) > 0)
-    return STRING;
+  if (STRING.size() > 0)
+    return STRING.c_str();
   else
     return defaultValue;
@@ -102,7 +101,7 @@
  * @return returns the contained string (char-array), if STRING was correct otherwise defaultValue
  */
-std::string isString(const char* STRING, const std::string& defaultValue)
+std::string isString(const std::string& STRING, const std::string& defaultValue)
 {
-  if (STRING != NULL && strlen(STRING) > 0)
+  if (STRING.size() > 0)
     return STRING;
   else
Index: branches/std/src/lib/util/helper_functions.h
===================================================================
--- branches/std/src/lib/util/helper_functions.h	(revision 7210)
+++ branches/std/src/lib/util/helper_functions.h	(revision 7211)
@@ -14,9 +14,9 @@
 *** HELPER FUNCTIONS ***
 ***********************/
-bool          isBool(const char* BOOL, bool defaultValue);
-int           isInt(const char* INT, int defaultValue);
-float         isFloat(const char* FLOAT, float defaultValue);
-const char*   isCString(const char* STRING, const char* defaultValue);
-std::string   isString(const char* STRING, const std::string& defaultValue);
+bool          isBool(const std::string& BOOL, bool defaultValue);
+int           isInt(const std::string& INT, int defaultValue);
+float         isFloat(const std::string& FLOAT, float defaultValue);
+const char*   isCString(const std::string& STRING, const char* defaultValue);
+std::string   isString(const std::string& STRING, const std::string& defaultValue);
 
 
Index: branches/std/src/lib/util/loading/load_param.cc
===================================================================
--- branches/std/src/lib/util/loading/load_param.cc	(revision 7210)
+++ branches/std/src/lib/util/loading/load_param.cc	(revision 7211)
@@ -67,5 +67,5 @@
     {
       PRINTF(4)("Loading '%s' with Parameters '%s' onto: '%s'(%s)\n", this->paramName, loadString.c_str(), this->object->getName(), this->object->getClassName());
-      this->executor->execute(this->object, &loadString);
+      this->executor->execute(this->object, (const void*)loadString.c_str());
     }
     delete this->executor;
Index: branches/std/src/lib/util/multi_type.cc
===================================================================
--- branches/std/src/lib/util/multi_type.cc	(revision 7210)
+++ branches/std/src/lib/util/multi_type.cc	(revision 7211)
@@ -39,4 +39,7 @@
   switch (this->type)
   {
+    default:
+      this->value.Float = 0.0f;
+      break;
     case MT_BOOL:
       this->value.Bool = false;
Index: branches/std/src/lib/util/multi_type.h
===================================================================
--- branches/std/src/lib/util/multi_type.h	(revision 7210)
+++ branches/std/src/lib/util/multi_type.h	(revision 7211)
@@ -106,8 +106,6 @@
 //      std::string*      String;
     }                   value;
-
+    std::string         storedString;
     MT_Type             type;
-
-    std::string         storedString;
 };
 
Index: branches/std/src/lib/util/substring.cc
===================================================================
--- branches/std/src/lib/util/substring.cc	(revision 7210)
+++ branches/std/src/lib/util/substring.cc	(revision 7211)
@@ -24,62 +24,14 @@
 #include "substring.h"
 
-#include "debug.h"
 #include <string.h>
-#include <assert.h>
-
-SubString::SubString( const char* string, char splitter)
-{
-  this->splittersCount = 0;
-  if (string == NULL)
-  {
-    this->strings = NULL;
-    this->offsets = NULL;
-    return;
-  }
-
-  for( int i = 0; i < strlen(string); i++)
-    if( string[i] == splitter)
-      this->splittersCount++;
-
-  this->splittersCount += 1;
-
-  this->strings = new char*[this->splittersCount];
-  this->offsets = new unsigned int[this->splittersCount];
-  assert (this->strings != NULL && this->offsets != NULL);
-
-  int i = 0;
-  int l = 0;
-
-  if( this->splittersCount > 1)
-  {
-    const char* offset = string;
-    const char* end = strchr( string, splitter);
-    while( end != NULL)
-    {
-      assert( i < this->splittersCount);
-      l = end - offset;
-      this->strings[i] = new char[l + 1];
-      assert( strings[i] != NULL);
-      strncpy( strings[i], offset, l);
-      strings[i][l] = '\0';
-      this->offsets[i] = offset - string;
-      i++;
-      end++;
-      offset = end;
-      end = strchr( offset, splitter);
-    }
-
-    l = strlen( offset);
-    strings[i] = new char[l + 1];
-    strncpy( strings[i], offset, l);
-    strings[i][l] = '\0';
-    this->offsets[i] = offset - string;
-  }
-  else
-  {
-    this->strings[0] = new char[strlen(string)+1];
-    strcpy(this->strings[0], string);
-    this->offsets[0] = 0;
-  }
+#include <cassert>
+
+SubString::SubString(const std::string& string, char splitter)
+{
+  char split[2];
+  split[0] = splitter;
+  split[1] = '\0';
+  SubString::splitLine(this->strings, this->offsets,
+                       string, split);
 }
 
@@ -91,137 +43,150 @@
  *
  */
-SubString::SubString(const char* string, bool whiteSpaces)
-{
-  this->splittersCount = 0;
-  if (string == NULL || whiteSpaces == false)
+SubString::SubString(const std::string& string, bool whiteSpaces)
+{
+  SubString::splitLine(this->strings, this->offsets,
+                      string);
+}
+
+SubString::SubString(const std::string& string, const std::string& splitters, char escapeChar,char safemode_char, char comment_char)
+{
+  SubString::splitLine(this->strings, this->offsets,
+                       string, splitters, escapeChar, safemode_char);
+}
+
+
+/**
+ * splits line into tokens and stores them in ret. Supports delimiters, escape characters,
+ * ignores special  characters between safemode_char and between comment_char and linend '\n'.
+ *
+ * @returns SPLIT_LINE_STATE the parser was in when returning
+ */
+SPLIT_LINE_STATE SubString::splitLine(std::vector<std::string>& ret, std::vector<unsigned int>& offsets,
+                                      const std::string& line, const std::string& delimiters,
+                                      char escape_char, char safemode_char, char comment_char,
+                                      SPLIT_LINE_STATE start_state)
+{
+  SPLIT_LINE_STATE state = start_state;
+  unsigned int i = 0;
+  std::string token;
+
+  if(start_state != SL_NORMAL && ret.size() > 0)
   {
-    this->strings = NULL;
-    this->offsets = NULL;
-    return;
+    token = ret[ret.size()-1];
+    ret.pop_back();
   }
 
-  // chop the input to the beginning of something usefull
-  if (strlen(string) > 0)
-    string = string + strspn(string, " \t\n");
-
-  // count the Splitters
-  bool lastWasWhiteSpace = false;
-  for(unsigned int i = 0; i < strlen(string); i++)
-    if( string[i] == ' ' || string[i] == '\t' || string[i] == '\n' )
-      lastWasWhiteSpace = true;
-    else
+  while(i < line.size())
+  {
+    switch(state)
     {
-      if (lastWasWhiteSpace)
-        this->splittersCount ++;
-      lastWasWhiteSpace = false;
+    case SL_NORMAL:
+      if(line[i] == escape_char)
+      {
+        state = SL_ESCAPE;
+      }
+      else if(line[i] == safemode_char)
+      {
+        state = SL_SAFEMODE;
+      }
+      else if(line[i] == comment_char)
+      {
+        /// FINISH
+        if(token.size() > 0)
+        {
+          ret.push_back(token);
+          offsets.push_back(i);
+          token.clear();
+        }
+        token += line[i];       // EAT
+        state = SL_COMMENT;
+      }
+      else if(delimiters.find(line[i]) != std::string::npos)
+      {
+        // line[i] is a delimiter
+        /// FINISH
+        if(token.size() > 0)
+        {
+          ret.push_back(token);
+          offsets.push_back(i);
+          token.clear();
+        }
+      }
+      else
+      {
+        token += line[i];       // EAT
+      }
+      break;
+    case SL_ESCAPE:
+      if(line[i] == 'n') token += '\n';
+      else if(line[i] == 't') token += '\t';
+      else if(line[i] == 'v') token += '\v';
+      else if(line[i] == 'b') token += '\b';
+      else if(line[i] == 'r') token += '\r';
+      else if(line[i] == 'f') token += '\f';
+      else if(line[i] == 'a') token += '\a';
+      else if(line[i] == '?') token += '\?';
+      else token += line[i];  // EAT
+      state = SL_NORMAL;
+      break;
+    case SL_SAFEMODE:
+      if(line[i] == safemode_char)
+      {
+        state = SL_NORMAL;
+      }
+      else if(line[i] == escape_char)
+      {
+        state = SL_SAFEESCAPE;
+      }
+      else
+      {
+        token += line[i];       // EAT
+      }
+      break;
+    case SL_SAFEESCAPE:
+      if(line[i] == 'n') token += '\n';
+      else if(line[i] == 't') token += '\t';
+      else if(line[i] == 'v') token += '\v';
+      else if(line[i] == 'b') token += '\b';
+      else if(line[i] == 'r') token += '\r';
+      else if(line[i] == 'f') token += '\f';
+      else if(line[i] == 'a') token += '\a';
+      else if(line[i] == '?') token += '\?';
+      else token += line[i];  // EAT
+      state = SL_SAFEMODE;
+      break;
+    case SL_COMMENT:
+      if(line[i] == '\n')
+      {
+        /// FINISH
+        if(token.size() > 0)
+        {
+          ret.push_back(token);
+          offsets.push_back(i);
+          token.clear();
+        }
+        state = SL_NORMAL;
+      }
+      else
+      {
+        token += line[i];       // EAT
+      }
+      break;
+    default:
+      // nothing
+      break;
     }
-  this->splittersCount += 1;
-
-  // allocate memory
-  this->strings = new char*[this->splittersCount];
-  this->offsets = new unsigned int[this->splittersCount];
-  assert (this->strings != NULL && this->offsets != NULL);
-
-
-  // split the String into substrings
-  int l = 0;
-  unsigned int i = 0;
-  if( this->splittersCount > 1)
+    i++;
+  }
+
+  /// FINISH
+  if(token.size() > 0)
   {
-    const char* offset = string;
-    const char* end = offset + strcspn(offset, " \t\n");
-    for (i = 0; i < this->splittersCount; i++)
-    {
-      assert( i < this->splittersCount);
-      l = end - offset;
-      this->strings[i] = new char[l + 1];
-      assert( strings[i] != NULL);
-      strncpy( strings[i], offset, l);
-      strings[i][l] = '\0';
-      this->offsets[i] = offset - string;
-      end += strspn(end, " \t\n");
-      offset = end;
-      end = offset + strcspn(offset, " \t\n");
-    }
+    ret.push_back(token);
+    offsets.push_back(i);
+    token.clear();
   }
-  else
-  {
-    unsigned int length = strcspn(string, " \t\n");
-    this->strings[0] = new char[length+1];
-    strncpy(this->strings[0], string, length);
-    this->strings[0][length] = '\0';
-    offsets[0] = 0;
-  }
-}
-
-SubString::SubString(const char* string, const char* splitters, char escapeChar)
-{
-  this->splittersCount = 0;
-  if (string == NULL || splitters == NULL)
-  {
-    this->strings = NULL;
-    this->offsets = NULL;
-    return;
-  }
-
-  // chop the input to the beginning of something usefull
-  if (strlen(string) > 0)
-    string = string + strspn(string, splitters);
-
-  // count the Splitters
-  bool lastWasSplitter = false;
-  for(unsigned int i = 0; i < strlen(string); i++)
-  {
-
-    if( strchr(splitters, string[i] ))
-      lastWasSplitter = true;
-    else
-    {
-      if (lastWasSplitter)
-      {
-        this->splittersCount ++;
-        lastWasSplitter = false;
-      }
-    }
-  }
-  this->splittersCount += 1;
-
-  // allocate memory
-  this->strings = new char*[this->splittersCount];
-  this->offsets = new unsigned int[this->splittersCount];
-  assert (this->strings != NULL && this->offsets != NULL);
-
-
-  // split the String into substrings
-  int l = 0;
-  unsigned int i = 0;
-  if( this->splittersCount > 1)
-  {
-    const char* offset = string;
-    const char* end = offset + strcspn(offset, splitters);
-    for (i = 0; i < this->splittersCount; i++)
-    {
-      assert( i < this->splittersCount);
-      l = end - offset;
-      this->strings[i] = new char[l + 1];
-      assert( strings[i] != NULL);
-      strncpy( strings[i], offset, l);
-      strings[i][l] = '\0';
-      this->offsets[i] = offset - string;
-      end += strspn(end, splitters);
-      offset = end;
-      end = offset + strcspn(offset, splitters);
-    }
-  }
-  else
-  {
-    unsigned int length = strcspn(string, splitters);
-    this->strings[0] = new char[length+1];
-    strncpy(this->strings[0], string, length);
-    this->strings[0][length] = '\0';
-    offsets[0] = 0;
-  }
-}
-
+  return(state);
+}
 
 /**
@@ -229,26 +194,5 @@
 */
 SubString::~SubString()
-{
-  if (this->strings)
-  {
-    for(unsigned int i = 0; i < this->splittersCount; i++)
-      delete[] this->strings[i];
-    delete[] this->strings;
-  }
-  delete[] this->offsets;
-}
-
-/**
- *  get a particular substring
- * @param i the ID of the substring to return
- * @returns the designated substring or NULL if an invalid ID was given
-*/
-const char* SubString::getString(unsigned int i)
-{
-  if( i < this->splittersCount && i >= 0)
-    return this->strings[i];
-  else
-    return NULL;
-}
+{ }
 
 /**
@@ -259,5 +203,5 @@
 unsigned int SubString::getOffset(unsigned int i)
 {
-  if( i < this->splittersCount && i >= 0)
+  if( i < this->offsets.size() && i >= 0)
     return this->offsets[i];
   else
@@ -270,8 +214,7 @@
 void SubString::debug() const
 {
-  PRINT(0)("Substring-information::count=%d ::", this->splittersCount);
-  if (this->strings != NULL)
-    for (unsigned int i = 0; i < this->splittersCount; i++)
-     PRINT(0)("s%d='%s'::", i, this->strings[i]);
-  PRINT(0)("\n");
-}
+  printf("Substring-information::count=%d ::", this->strings.size());
+  for (unsigned int i = 0; i < this->strings.size(); i++)
+    printf("s%d='%s'::", i, this->strings[i].c_str());
+  printf("\n");
+}
Index: branches/std/src/lib/util/substring.h
===================================================================
--- branches/std/src/lib/util/substring.h	(revision 7210)
+++ branches/std/src/lib/util/substring.h	(revision 7211)
@@ -7,17 +7,33 @@
 #define _SUBSTRING_H
 
+#include <vector>
+#include <string>
+
+  typedef enum {
+    SL_NORMAL,
+    SL_ESCAPE,
+    SL_SAFEMODE,
+    SL_SAFEESCAPE,
+    SL_COMMENT,
+  } SPLIT_LINE_STATE;
+
 //! A class that can load one string and split it in multipe ones
 class SubString
 {
  public:
-  SubString(const char* string, char splitter = ',');
-  SubString(const char* string, bool whiteSpaces);
-  SubString(const char* string, const char* splitters, char escapeChar ='\\');
+  SubString(const std::string& string, char splitter = ',');
+  SubString(const std::string& string, bool whiteSpaces);
+  SubString(const std::string& string, const std::string& splitters, char escapeChar ='\\', char safemode_char = '"', char comment_char = '\0');
   ~SubString();
 
-  const char* operator[](unsigned int i) { return this->getString(i); };
+  SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,std::vector<unsigned int>& offsets,
+                             const std::string& line, const std::string& delimiters = " \t\r\n",
+                             char escape_char = '\\', char safemode_char = '"', char comment_char = '\0',
+                             SPLIT_LINE_STATE start_state = SL_NORMAL);
 
-  inline unsigned int getCount() { return this->splittersCount; };
-  const char* getString(unsigned int i);
+  const std::string& operator[](unsigned int i) { return this->getString(i); };
+
+  inline unsigned int getCount() { return this->strings.size(); };
+  const std::string& getString(unsigned int i) { return this->strings[i]; };
   unsigned int getOffset(unsigned int i);
 
@@ -25,7 +41,6 @@
 
  private:
-  char**          strings;                      //!< strings produced from a single string splitted in multiple strings
-  unsigned int*   offsets;                      //!< offsets of the beginning of the input-string to the beginning of each substring.
-  unsigned int    splittersCount;               //!< how many splitted parts
+   std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
+   std::vector<unsigned int> offsets;                      //!< offsets of the beginning of the input-string to the beginning of each substring.
 };
 
