faststring3.h

#ifndef FASTSTRING3_H
#define FASTSTRING3_H

// With version 3 this is strictly 64 bit.
// Before version 3 this should have been 64 bit compatible.

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <climits>
#include <stdarg.h>
#include <vector>
#include <cmath>
#include <cerrno>
#include <list>
#include <cfloat>
#include <climits>

#define _MINBUFFER_CAPACITY 4

// Uncomment when using a 64bit windows machine. 
// #define _WIN64

// Includes the symbols which occur in the blosum matrices: 
const char toupper_lookup[] = {
  '\0',  '\1',  '\2',  '\3',  '\4',  '\5',  '\6',  '\7', '\10', '\11', //   0- 9
  '\12', '\13', '\14', '\15', '\16', '\17', '\20', '\21', '\22', '\23', //  10-19
  '\24', '\25', '\26', '\27', '\30', '\31', '\32', '\33', '\34', '\35', //  20-29
  '\36', '\37', '\40', '\41', '\42', '\43', '\44', '\45', '\46', '\47', //  30-39
  '\50', '\51', '\52', '\53', '\54', '\55', '\56', '\57', '\60', '\61', //  40-49
  '\62', '\63', '\64', '\65', '\66', '\67', '\70', '\71', '\72', '\73', //  50-59
  '\74', '\75', '\76', '\77','\100','\101','\102','\103','\104','\105', //  60-69
  '\106','\107','\110','\111','\112','\113','\114','\115','\116','\117', //  70-79
  '\120','\121','\122','\123','\124','\125','\126','\127','\130','\131', //  80-89
  '\132','\133','\134','\135','\136','\137','\140','\101','\102','\103', //  90-99
  '\104','\105','\106','\107','\110','\111','\112','\113','\114','\115', // 100-109
  '\116','\117','\120','\121','\122','\123','\124','\125','\126','\127', // 110-119
  '\130','\131','\132','\173','\174','\175','\176','\177',               // 120-127
                                                                         // extended ascii code:
  '\200','\201',
  '\202','\203','\204','\205','\206','\207','\210','\211','\212','\213',
  '\214','\215','\216','\217','\220','\221','\222','\223','\224','\225',
  '\226','\227','\230','\231','\232','\233','\234','\235','\236','\237',
  '\240','\241','\242','\243','\244','\245','\246','\247','\250','\251',
  '\252','\253','\254','\255','\256','\257','\260','\261','\262','\263',
  '\264','\265','\266','\267','\270','\271','\272','\273','\274','\275',
  '\276','\277','\300','\301','\302','\303','\304','\305','\306','\307',
  '\310','\311','\312','\313','\314','\315','\316','\317','\320','\321',
  '\322','\323','\324','\325','\326','\327','\330','\331','\332','\333',
  '\334','\335','\336','\337','\340','\341','\342','\343','\344','\345',
  '\346','\347','\350','\351','\352','\353','\354','\355','\356','\357',
  '\360','\361','\362','\363','\364','\365','\366','\367','\370','\371',
  '\372','\373','\374','\375','\376','\377'
};

const char tolower_lookup[] = {
  '\0',  '\1',  '\2',  '\3',  '\4',  '\5',  '\6',  '\7', '\10', '\11', //   0- 9
  '\12', '\13', '\14', '\15', '\16', '\17', '\20', '\21', '\22', '\23', //  10-19
  '\24', '\25', '\26', '\27', '\30', '\31', '\32', '\33', '\34', '\35', //  20-29
  '\36', '\37', '\40', '\41', '\42', '\43', '\44', '\45', '\46', '\47', //  30-39
  '\50', '\51', '\52', '\53', '\54', '\55', '\56', '\57', '\60', '\61', //  40-49
  '\62', '\63', '\64', '\65', '\66', '\67', '\70', '\71', '\72', '\73', //  50-59
  '\74', '\75', '\76', '\77','\100','\141','\142','\143','\144','\145', //  60-69
  '\146','\147','\150','\151','\152','\153','\154','\155','\156','\157', //  70-79
  '\160','\161','\162','\163','\164','\165','\166','\167','\170','\171', //  80-89
  '\172','\133','\134','\135','\136','\137','\140','\141','\142','\143', //  90-99
  '\144','\145','\146','\147','\150','\151','\152','\153','\154','\155', // 100-109
  '\156','\157','\160','\161','\162','\163','\164','\165','\166','\167', // 110-119
  '\170','\171','\172','\173','\174','\175','\176','\177',               // 120-127
                                                                         // extended ascii code:
  '\200','\201',
  '\202','\203','\204','\205','\206','\207','\210','\211','\212','\213',
  '\214','\215','\216','\217','\220','\221','\222','\223','\224','\225',
  '\226','\227','\230','\231','\232','\233','\234','\235','\236','\237',
  '\240','\241','\242','\243','\244','\245','\246','\247','\250','\251',
  '\252','\253','\254','\255','\256','\257','\260','\261','\262','\263',
  '\264','\265','\266','\267','\270','\271','\272','\273','\274','\275',
  '\276','\277','\300','\301','\302','\303','\304','\305','\306','\307',
  '\310','\311','\312','\313','\314','\315','\316','\317','\320','\321',
  '\322','\323','\324','\325','\326','\327','\330','\331','\332','\333',
  '\334','\335','\336','\337','\340','\341','\342','\343','\344','\345',
  '\346','\347','\350','\351','\352','\353','\354','\355','\356','\357',
  '\360','\361','\362','\363','\364','\365','\366','\367','\370','\371',
  '\372','\373','\374','\375','\376','\377'
};

class CharLookup
{
 private:
  char lookup_array[256];

 public:
  CharLookup()
  {
    for (unsigned short i=0; i<256; ++i)
    {
      lookup_array[i] = i;
    }
  }

  CharLookup(int v)
  {
    std::memset(lookup_array, v, 256);
  }

  void add(unsigned char index, char val=1)
  {
    lookup_array[(unsigned char)index] = val;
  }

  bool check(unsigned char index) const
  {
    return lookup_array[index];
  }

  char value(unsigned char index) const
  {
    return lookup_array[index];
  }
};


inline char toupper_char(char c)
{
  return toupper_lookup[(unsigned char)c];
}

inline char tolower_char(char c)
{
  return tolower_lookup[(unsigned char)c];
}

#define macromin(x,y) ((x)<(y) ? (x) : (y))
//#define macromax(x,y) ((x)>(y) ? (x) : (y))

class faststring;

template <typename Container>
typename Container::size_type
split (Container &l, const faststring &s, char const * const ws = "\r\n\t\v\f ");

template <typename Container>
typename Container::size_type
split_at (Container &l, const faststring &s, const faststring &delim);

template <typename Container>
typename Container::size_type
split_respect (Container &l, const faststring &s, char const * const ws = "\r\n\t\v\f ");

template <typename Container>
typename Container::size_type
split_strict (Container &l, const faststring &s, char const * const ws = " \t\n");

namespace {
  inline bool is_in_symbol_list__(char c, const char* wstr="\r\n\t\v\f ")
  {
    return (strchr(wstr,c) != NULL);
  }
  
  inline bool is_in_symbol_list__(char c, const char* wstr, size_t n)
  {
    return (memchr(wstr,c,n) != NULL);
  }
  
  const char * find_fundamental ( const char *b1, const char *e1,
                                 const char *b2, const char *e2)
  {
    for (; b1 < e1 ; ++b1)
    {
      const char * tb1 = b1; // tmp b1, b2
      const char * tb2 = b2;
      for (; tb2 < e2 && tb1 < e1; ++tb2, ++tb1)
      {
        if (*tb1 != *tb2)
          break;
      }
      if (tb2 == e2) // we have a match
      {
        return b1;
      }
    }
    return NULL;
  }
  
  const char * rfind_fundamental ( const char *rb1, const char *re1,
                                  const char *rb2, const char *re2)
  {
    for (; rb1 > re1 ; --rb1)
    {
      const char * trb1 = rb1;
      const char * trb2 = rb2;
      for (; trb2 > re2 && trb1 > re1; --trb2, --trb1)
      {
        if (*trb1 != *trb2)
          break;
      }
      if (trb2 == re2) // we have a match
      {
        return trb1+1;
      }
    }
    return NULL;
  }
  
  
} // End namespace




class faststring
{
public:
  // Formerly we used unsigned and not unsigned long. The problem is:
  // On 64 bit machines, const char * has 8 byte and is sometimes mixed with
  // size_type, e.g. in
  // size_type len = end-start;
  typedef size_t size_type;  // Define faststring::size_type in analogy to string::size_type

  static const size_type npos = ULLONG_MAX;
  static size_type max_size() {  return npos; }

  // Possibly even more efficient:
  //    Use pointer _end, _capacity_end instead of _len, _capacity
  
  
private:
  char       *_buf;
  size_type  _len;
  size_type  _capacity;   // Capacity of container, i.e number of bytes available
                          // for writing. If a capacity is requested by the user,
                          // an additional byte is reserved in order to be able to append
                          // the additional \0 which is appended by some function calls.
                          // Consequently, the capacity reported to user is _capacity-1.
  
protected:
  
public:
  ~faststring ()
  {
    if (_buf)
      std::free(_buf);
  }
  
  faststring ():_buf(NULL),  _len(0), _capacity(0) // :_len(0), _capacity(a)
  {
    //    _buf = (char *)malloc(_MINBUFFER_CAPACITY);
  }
  
  faststring (const char *str)
  {
    _len      = (size_type)strlen(str);
    _capacity = _len+1;
    _buf      = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    memcpy(_buf, str, _len);
    
  }
  
  // The following constructor cannot do much error checking, since it is very general.
  // It can take pointers from c-strings etc, for which no error checking is possible.
  // If the pointers originalte from another faststring object, consider to use the substr function with the same parameters.
  faststring (const char *str_begin, const char *str_end)
  {
    if (str_end > str_begin)
    {
      _len      = (str_end) - str_begin;
      _capacity = _len + 1;
      _buf      = (char *)malloc(_capacity);
      if (_buf == 0)
      {
        std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
        exit(-1);
      }
      memcpy(_buf, str_begin, _len);
    }
    else
    {
      _buf = NULL;
      _len = _capacity = 0;
    }
  }
  
  faststring (const faststring &a):_len(a._len),_capacity(a._len+1)
  {
    if (a._buf == NULL)
    {
      _buf = 0;
      _len = 0;
      _capacity = 0;
      return;
    }
    
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    memcpy(_buf, a._buf, _len);
  }
  
  faststring(size_type n, char c):_len(n),_capacity(n+1)
  {
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    
    memset(_buf, c, _len);
    /*
     size_type i;
     for (i=0; i<n; ++i)
     _buf[i] = c; */
  }
  
  faststring(char c):_len(1),_capacity(2)
  {
    _buf = (char *)malloc(2);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    memset(_buf, c, 1);
  }
  
  faststring(int i)
  {
    _capacity = (size_type)(sizeof(i)*8*.31+3);   // bits * 1/log_2(10) + 3 for ciel and sign and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf, _capacity, "%d", i);
    _len = (size_type)strlen(_buf);
    //    std::cout << "Capacity: " << _capacity << std::endl;
  }
  
  faststring(unsigned i)
  {
    _capacity = (size_type)(sizeof(i)*8*.31+3);   // bits * 1/log_2(10) + 3 for ciel and sign and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf, _capacity, "%u", i);
    _len = (size_type)strlen(_buf);
    //    std::cout << "Capacity: " << _capacity << std::endl;
  }
  
  // Prints the unsigned i into the string. The number appears right-justified.
  // len is the minimum length of the field. If the number needs more digits it well get them.
  // If the number need less than len digits they will be left padded with the fill char.
  // Example: Calling constructor with 999, '#', 5 will result in the string "##999", for 999, '#', 2 we get "999".
  faststring(unsigned i, char fill, int len)
  {
    int num_digits = (i>0) ? ((int) std::log10 ((double)i))+1 : 1; // We take care not to pass 0 to log10
    
    _capacity = num_digits+1;
    if (len >= num_digits)
      _capacity = len+1;
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf,_capacity, "%0*u", len, i); // left padded with zeros (0)
                                              // Replace left padded zeros with fill char
    
    size_type pos = 0;
    size_type e   = _capacity-2;
    while (pos < e && _buf[pos]=='0')
    {
      _buf[pos] = fill;
      ++pos;
    }
    ++e;
    while (pos < e && _buf[pos] )
      ++pos;
    _len = pos;
    //    std::cout << "Capacity: " << _capacity << std::endl;
  }
  
  faststring(long i)
  {
    _capacity = (size_type)(sizeof(i)*8*.31+3);   // bits * 1/log_2(10) + 3 for ciel and sign and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf, _capacity, "%ld", i);
    _len = (size_type)strlen(_buf);
  }
  
  faststring(unsigned long i)
  {
    _capacity = (size_type)(sizeof(i)*8*.31+3);   // bits * 1/log_2(10) + 3 for ciel and sign and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf, _capacity,"%lu", i);
    _len = (size_type)strlen(_buf);
  }
  
  faststring(float f, int pres=6)
  {
    _capacity = FLT_MAX_10_EXP + pres + 3; // +3 sign, decimal point and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf, _capacity,"%.*f", pres, f);
    _len = (size_type)strlen(_buf);
  }
  
  // Default precision.
  faststring(float f, char c)
  {
    (void) c;
    _capacity = FLT_MAX_10_EXP + 10 + 3; // +3 sign, decimal point and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf, _capacity,"%g", f);
    _len = (size_type)strlen(_buf);
  }
  
  faststring(double f, int pres=14)
  {
    _capacity = DBL_MAX_10_EXP + pres + 3; // +3 sign, decimal point and \0, DBL_MAX_10_EXP is basically the maximum number of digits maybe without decimals.
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf,_capacity, "%.*f", pres, f); // f ist correct. lf is also allowed but l is ignored.
    _len = (size_type)strlen(_buf);
  }
  
  // Automatically determines the precision.
  faststring(double f, char c)
  {
    (void) c;
    _capacity = DBL_MAX_10_EXP + 20 + 3; // +3 sign, decimal point and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf,_capacity, "%g", f);
    _len = (size_type)strlen(_buf);
  }
  
  // In the following function, the parameter bool b is not used directly. It has been introduced to distinguish this variant of the constructor
  // from the variants declared above.
  // Uses format string "%.*g" instead of "%.*f". Explanation:  "Use the shortest representation: %e or %f".
  faststring(double f, int pres, bool b)
  {
    (void) b;
    
    _capacity = DBL_MAX_10_EXP + pres + 5; // +5 sign, decimal point, E, sign and \0
    _buf = (char *)malloc(_capacity);
    if (_buf == 0)
    {
      std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring constructor." << std::endl;
      exit(-1);
    }
    snprintf(_buf,_capacity, "%.*g", pres, f);
    _len = (size_type)strlen(_buf);
    
    //    std::cerr << "faststring len: " << _len << std::endl;
  }
  
  faststring &operator+=(const faststring &s)
  {
    this->append(s);
    return *this;
  }
  
  void push_back(char c)
  {
    if (_capacity == _len)
    {
      if (_buf == 0)
      {
        _capacity = _MINBUFFER_CAPACITY;
        _buf = (char *)malloc(_capacity);
        if (_buf == 0)
        {
          std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring push_back." << std::endl;
          exit(-1);
        }
      }
      else
      {
        _capacity <<= 1;
        _buf = (char *)realloc(_buf, _capacity);
        if (_buf == 0)
        {
          std::cerr << "Critical error: realloc failed when requesting " << _capacity << " bytes in faststring push_back." << std::endl;
          exit(-1);
        }
      }
    }
    _buf[_len] = c;
    ++_len;
  }
  
  
  
  void pop_back()
  {
    if (_len >0)
      --_len;
  }
  
  char get_last()
  {
    if (_len >0)
      return _buf[_len-1];
    else
      return '\0';
  }
  
  char& back()
  {
    if (_len == 0)
    {
      std::cerr << "Critical error: back() called for faststring of length 0. Exiting.\n";
      exit(-1);
    }
    return _buf[_len-1];
  }
  
  char get_last_and_pop()
  {
    if (_len >0)
    {
      --_len;
      return _buf[_len];
    }
    else
      return '\0';
  }
  
  // Sometimes strings have to end with a certain character.
  // If this is present, nothing will be done.
  // If this is not present, the character will be appended.
  void ensure_string_ends_with(char c)
  {
    if (get_last() != c)
    {
      push_back(c);
    }
  }
  
  /*   void ensure_string_does_not_end_with(char c) */
  /*   { */
  /*     while (_len > 0 && get_last() == c) */
  /*     { */
  /*       pop_back(); */
  /*     } */
  /*   } */
  
  // chomp in perl: (Removing a trailing \0 is not allowed. Also consider removeSpacesBack()
  void pop_trailing_characters(char c)
  {
    // get_last() and pop_back() both ensure that _len>0
    if (c == '\0') // Problem: get_last returns \0 if the len=0, so we would end up with an infinite loop if we remove \0 in an empty string.
      return;
    
    while (get_last() == c)
    {
      pop_back();
    }
  }
  
  const char *c_str()
  {
    if (_capacity == 0) // We reserve 1 byte for the empty cstring.
    {
      _capacity = 1;
      _len = 0;
      _buf      = (char *)malloc(_capacity);
      if (_buf == 0)
      {
        std::cerr << "Critical error: malloc failed when requesting " << _capacity << " bytes in faststring c_str()." << std::endl;
        exit(-1);
      }
      *_buf = '\0';
      return _buf;
    }
    
    if (_capacity == _len)
    {
      ++_capacity;
      _buf = (char *)realloc(_buf, _capacity);
    }
    
    //  if (_buf[_len] == '\0')
    //    return _buf;
    
    _buf[_len] = '\0';
    return _buf;
  }
  
  
  char *begin() const
  {
    return _buf;
  }

  char *begin_str() const
  {
    return _buf;
  }

  char *data() const
  {
    return _buf;
  }

  char *end() const
  {
    return _buf+_len;
  }

  char *end_str() const
  {
    return _buf+_len;
  }

  char *rbegin() const
  {
    return _buf+_len-1;
  }

  char *rend() const
  {
    return _buf-1;
  }

  char *rbegin_str() const
  {
    return _buf+_len-1;
  }

  char *rend_str() const
  {
    return _buf-1;
  }

  bool empty() const
  {
    return (_len == 0);
  }
  
  void reverse()
  {
    char *i1, *i2;
    char c;
    
    i1 = begin_str();
    i2 = rbegin_str();
    
    while (i1<i2)
    {
      c = *i1;
      *i1 = *i2;
      *i2 = c;
      ++i1;
      --i2;
    }
  }
  
  
  //=================================================
  // assign family:
  //=================================================
  // string& assign ( const string& str );
  // string& assign ( const string& str, size_type pos, size_type n );
  // string& assign ( const char* s, size_type n );
  // string& assign ( const char* s );
  // string& assign ( size_type n, char c );
  // template <class InputIterator>
  //   string& assign ( InputIterator first, InputIterator last );
  
  faststring& assign(const char *str)
  {
    _len = (size_type)strlen(str);
    reserve(_len);
    memcpy(_buf, str, _len);
    return *this;
  }
  
  // n is the maximum number of chars that will be assigned.
  faststring& assign(const char *str, size_type n)
  {
    _len = n;
    size_type ll = (faststring::size_type)strlen(str);
    if (_len > ll)  // if n > ll, we have to reduce _len to ll
      _len = ll;
    reserve(_len);
    memcpy(_buf, str, _len);
    return *this;
  }
  
  faststring& assign(const char *str_begin, const char *str_end)
  {
    if (str_end > str_begin)
    {
      _len = str_end - str_begin;
      reserve(_len);
      memcpy(_buf, str_begin, _len);
    }
    else
    {
      clear();
    }
    return *this;
  }
  
  faststring& assign(const faststring &str)
  {
    _len = str._len;
    reserve(_len);
    memcpy(_buf, str._buf, _len);
    return *this;
  }
  
  faststring& assign(const faststring &str, size_type pos, size_type n=npos )
  {
    if (n == npos || n+pos > str._len)
      n = str._len-pos;
    _len = n;
    reserve(_len+1);
    memcpy(_buf, str._buf+pos, n);
    return *this;
  }
  
  // Could be made more efficient. TODO
  faststring& assign( size_type n, char c )
  {
    clear();
    reserve(n);
    size_type i;
    for (i=0; i<n; ++i)
      push_back(c);
    return *this;
  }
  
  
  
  
  //=================================================
  // The family of append functions:
  //=================================================
  // basic_string& append(const basic_string& s)	basic_string	 Append s to *this.
  // basic_string& append(const basic_string& s,
  //                      size_typeype pos, size_typeype n)
  // basic_string	 Append a substring of s to *this.
  // basic_string& append(const charT* s)	basic_string	 Append s to *this.
  // basic_string& append(const charT* s, size_typeype n)	basic_string	 Append the first n characters of s to *this.
  // basic_string& append(size_typeype n, charT c)	basic_string	 Append n copies of c to *this.
  // template <class InputIterator>
  // basic_string& append(InputIterator first, InputIterator last)
  // basic_string	 Append a range to *this.
  
  
  // step imp-fin
  faststring& append(const char *s)
  {
    // The costs of determining the length are almost as high as copying the whole string character by character.
    while (*s)
    {
      push_back(*s);
      ++s;
    }
    
    /*
     int old_len = _len;
     int s_len   = strlen(s);
     int new_len = old_len + s_len;
     
     _len = new_len;
     
     reserve(new_len);
     memcpy(_buf+old_len, s, s_len);
     */
    return *this;
  }
  
  // step imp-fin
  faststring& append(const faststring &s)
  {
    size_type old_len = _len;
    size_type s_len   = s._len;
    size_type new_len = old_len + s_len;

    reserve(new_len);
    _len = new_len;

    memcpy(_buf+old_len, s._buf, s_len);
    return *this;
  }
  
  // step imp-fin
  faststring& append(const faststring& s, size_type pos, size_type n=npos)
  {
    if (n==npos || pos+n > s.length() )
      n = s.length()-pos;
    
    size_type old_len = _len;
    size_type new_len = old_len + n;
    
    _len = new_len;
    
    reserve(new_len);
    memcpy(_buf+old_len, s._buf+pos, n);
    return *this;
  }
  
  // step imp-fin
  faststring& append(const char* s, size_type n)
  {
    size_type old_len = _len;
    size_type new_len = old_len + n;
    
    _len = new_len;
    
    reserve(new_len);
    memcpy(_buf+old_len, s, n);
    return *this;
  }
  
  // step imp-fin
  faststring& append(size_type n, char c)
  {
    size_type old_len = _len;
    size_type new_len = old_len + n;
    
    reserve(new_len);
    size_type i;
    for (i=0; i<n; ++i)
      push_back(c);
    return *this;
  }
  
  // step imp-fin
  faststring& append(const char * first_it, const char * end_it)
  {
    size_type old_len = _len;
    size_type n       = end_it-first_it;
    size_type new_len = old_len + n;
    
    _len = new_len;
    
    reserve(new_len);
    memcpy(_buf+old_len, first_it, n);
    return *this;
  }
  
  
  
  //---------------------------------------
  // Side effects:  Invalidates pointers.
  //---------------------------------------
  void reserve(size_type s)
  {
    if (_capacity >= s)
      return;
    
    ++s;   // Reserve one more char in case we have to append a \0 at end of string later.
           // Well this could be seen as a wast of memory.
    if (_buf == NULL)
    {
      _buf = (char *)malloc(s);
      if (_buf == 0)
      {
        std::cerr << "Critical error: Trying again to malloc " << s << " bytes in faststring reserve()." << std::endl;
        _buf = (char *)malloc(s);
      }
      if (_buf == 0)
      {
        std::cerr << "Critical error: malloc failed when requesting " << s << " bytes in faststring reserve()." << std::endl;
        exit(-1);
      }
    }
    else
    {
      _buf = (char *)realloc(_buf, s);
      if (_buf == 0)
      {
        std::cerr << "Critical error: realloc failed when requesting " << s << " bytes in faststring reserve()." << std::endl;
        exit(-1);
      }
    }
    _capacity = s;
  }
  
  
  
  // Returns the part of the string following the last occurrence of delim.
  // If the character does not occur, the full string is returned.
  // The second parameter can be used to specify a minimum number of characters that need to
  // be found before the extension. fpos_minimum == 1: The extension cannot start at index 0.
  faststring get_string_extension_or_all(char delim, size_type fpos_minimum = 0)
  {
    size_type fpos = this->rfind(delim);
    
    if (fpos < fpos_minimum)
      fpos = npos;
    
    if (fpos == npos)
      return *this;
    else
    {
      faststring res(this->begin()+fpos+1, this->end());
      return res;
    }
  }
  
  // Returns the part of the string following the last occurrence of delim.
  // If the character does not occur, the empty string is returned.
  // The second parameter can be used to specify a minimum number of characters that need to
  // be found before the extension. fpos_minimum == 1: The extension cannot start at index 0.
  faststring get_string_extension(char delim, size_type fpos_minimum = 0)
  {
    size_type fpos = this->rfind(delim);
    
    if (fpos < fpos_minimum)
      fpos = npos;
    
    if (fpos == npos)
      return faststring();
    else
    {
      faststring res(this->begin()+fpos+1, this->end());
      return res;
    }
  }
  
  
  // Returns the part of the string before the last occurrence of delim.
  // If the character does not occur, the empty string is returned.
  // The second parameter can be used to specify a minimum number of characters that need to
  // be found before the extension. fpos_minimum == 1: The extension cannot start at index 0.
  faststring get_string_before_extension(char delim, size_type fpos_minimum = 0)
  {
    size_type fpos = this->rfind(delim);
    
    if (fpos < fpos_minimum)
      fpos = npos;
    
    if (fpos == npos)
      return faststring();
    else
    {
      faststring res(this->begin(), this->begin()+fpos);
      return res;
    }
  }
  
  // Returns the part of the string before the last occurrence of delim.
  // If the character does not occur, the full string is returned.
  // The second parameter can be used to specify a minimum number of characters that need to
  // be found before the extension. fpos_minimum == 1: The extension cannot start at index 0.
  faststring get_string_before_extension_or_all(char delim, size_type fpos_minimum = 0)
  {
    size_type fpos = this->rfind(delim);
    
    if (fpos < fpos_minimum)
      fpos = npos;
    
    if (fpos == npos)
      return *this;
    else
    {
      faststring res(this->begin(), this->begin()+fpos);
      return res;
    }
  }
  
  
  // Filename functions:
  // Deprecated: should be removed soon. Wrong name.
  faststring filename_base()
  {
    faststring res(*this);
    res.shorten(res.rfind('.'));
    return res;
  }
  
  faststring filename_dirname_and_basename() const
  {
    faststring res = filename_dirname();
    res += "/";
    res += filename_basename();
    return res;
  }
  
  // Acts like the linux command does, but accepts only one argument.
  faststring filename_basename() const
  {
    if (size() == 0) // If string is empty before removing anything we return ".".
      return ".";
    
    faststring tmp = *this;
    tmp.removeSpacesBack(" /"); // Removes trailing spaces and "/" characters
    
    if (tmp.size() == 0) // In the end "/" or "//" will result in "/".
      return "/";
    
    faststring res = tmp.get_string_extension_or_all('/');
    return res;
  }
  
  // Acts like the linux command does, but accepts only one argument.
  faststring filename_dirname() const
  {
    if (size() == 0) // If string is empty before removing anything we return ".".
      return ".";
    
    faststring tmp = *this;
    tmp.removeSpacesBack(" /"); // Removes trailing spaces and "/" characters
    
    if (tmp.size() == 0) // Note: Multiple //// are collapsed to "/"
      return "/";
    
    faststring before_delim = tmp.get_string_before_extension('/');
    
    if (before_delim.empty() )
    {
      if (tmp[0] == '/')  // Example: /usr -> dirname must be "/". If the only / is the root, this is the dirname
        return "/";
      
      return ".";
    }
    return before_delim;
  }
  
  
  // Deprecated. - Replaced by filename_dirname() which mimics the dirname command in linux much better.
  faststring filename_path() const
  {
    faststring res(*this);
    size_type fpos = res.rfind('/');
    
    if (fpos == npos)
      return ".";
    else
    {
      res.shorten(fpos);
      return res;
    }
  }
  
  faststring filename_basename_without_extension() const
  {
    faststring tmp  = filename_basename();
    return tmp.get_string_before_extension_or_all('.',1);
  }
  
  faststring filename_dirname_and_basename_without_extension() const
  {
    faststring tmp  = filename_dirname();
    tmp += "/";
    tmp += filename_basename_without_extension();
    return tmp;
  }
  
  
  
  // Returns the last part of the filename, i.e. the part after the last relevant "/".
  // If this sting contains the basename this is the base name with extension.
  // If the string ends with a directory, this is the directory.
  // Some special cases are catched.
  // Deprecated and replaced by the filename_basename function.
  
  /*   faststring filename_FileOrDirName() */
  /*   { */
  /*     unsigned fpos = this->rfind('/'); */
  
  /*     if (fpos == npos) */
  /*       return *this; */
  /*     else */
  /*     { */
  /*       faststring res(this->begin()+fpos+1, this->end()); */
  /*       return res; */
  /*     } */
  /*   } */
  
  faststring filename_extension() const
  {
    // If we do not restrict the search to the basename, dots in the path can cause problems
    // if the file does not have a file extension.
    faststring tmp = filename_basename();
    return tmp.get_string_extension('.', 1);
  }
  
  // END filename functions
  
  // Searches the string backwards for delim. Divides the string at delim if delim is found in backward direction
  // before break_at. So if in forward direction delim occurs only before break_at or if delim does not occur, the
  // string cannot be divided in the requested way. In this case pre gets the string und post is empty.
  
  bool backwards_search_divide_at_break_at(char delim, char break_at, faststring &pre, faststring &post) const
  {
    size_type len = length();
    size_type i = len-1;
    int    mode = 0;
    
    while (i > 0)
    {
      if (get_unckecked(i) == delim) // Yea, we found delim behind any occurrence of break_at
      {
        mode = 2;
        break;
      }
      if (get_unckecked(i) == break_at) // We could not find the delim before break_at, so we have to stop.
      {
        mode = 1;
        break;
      }
      
      --i;
    }
    
    if (mode == 2)
    {
      pre  = substr(0, i);
      post = substr(i+1, npos);
      return true;
    }
    else // if mode == 0 or 1
    {
      pre = *this;
      post = "";
      return false;
    }
  }
  
  bool divide_at(char delim, faststring &pre, faststring &post) const
  {
    size_type pos = find(delim,0);
    if (pos == npos)
    {
      post.clear();
      pre = *this;
      return false;
    }
    post = substr(pos+1, npos);
    pre  = substr(0, pos);
    return true;
  }
  
  bool divide_at_first_of(const char *delims, faststring &pre, faststring &post) const
  {
    size_type pos = find_first_of(delims,0);
    if (pos == npos)
      return false;
    post = substr(pos+1, npos);
    pre  = substr(0, pos);
    return true;
  }
  
  bool divide_at_last_of(const char *delims, faststring &pre, faststring &post) const
  {
    size_type pos = find_last_of(delims);
    if (pos == npos)
      return false;
    post = substr(pos+1, npos);
    pre  = substr(0, pos);
    return true;
  }
  
  bool divide_at(faststring delim, faststring &pre, faststring &post) const
  {
    size_type pos = find(delim,0);
    if (pos == npos)
      return false;
    post = substr(pos+delim.size(), npos);
    pre  = substr(0, pos);
    return true;
  }
  
  bool string_after_delimiter(const faststring &delim, faststring &post)
  {
    post.clear();
    size_type pos = find(delim,0);
    if (pos == npos)
      return false;
    post = substr(pos+delim.size(), npos);
    return true;
  }
  
  bool string_before_delimiter(const faststring &delim, faststring &pre)
  {
    pre.clear();
    size_type pos = find(delim,0);
    if (pos == npos)
      return false;
    pre = substr(0, pos);
    return true;
  }
  
  bool string_between_delimiters(const faststring &delim1, const faststring &delim2, faststring &res)
  {
    res.clear();
    size_type pos1 = find(delim1,0);
    if (pos1 == npos)
      return false;
    size_type pos2 = find(delim2,pos1+delim1.size());
    if (pos2 == npos)
      return false;
    
    std::cout << "pos1: " << pos1 << " pos2: " << pos2 << std::endl;
    
    size_type s = pos1+delim1.size();
    size_type e = pos2;
    std::cout << "s: " << s << " e: " << e << std::endl;
    res = substr(s,e-s);
    return true;
  }
  
  size_type size() const
  {
    return _len;
  }
  
  size_type length() const
  {
    return _len;
  }
  
  size_type capacity() const
  {
    return _capacity; // One char is reserved for the \0 at end of string
  }
  
  size_type memory_usage() const
  {
    return sizeof(*this) + capacity();
  }
  
  
  void set_unckecked(size_type pos, char c)
  {
    _buf[pos] = c;
  }
  
  bool check_pos(size_type pos)
  {
    return (pos < _len);
  }
  
  bool set(size_type pos, char c)
  {
    if ( check_pos(pos) )
    {
      _buf[pos] = c;
      return true;
    }
    else
    {
      return false;
    }
  }
  
  
  void get_unckecked(size_type pos, char &c) const
  {
    c = _buf[pos];
  }
  
  char get_unckecked(size_type pos) const
  {
    return _buf[pos];
  }
  
  char & at(size_type pos)
  {
    return _buf[pos];
  }
  
  bool get(size_type pos, char &c)
  {
    if ( check_pos(pos) )
    {
      c = _buf[pos];
      return true;
    }
    else
    {
      return false;
    }
  }

  void tolower_slow()
  {
    char *b = begin();
    char *e = end();

    while (b != e)
    {
      *b = std::tolower(*b);
      ++b;
    }
  }

  void tolower()
  {
    unsigned char *b = (unsigned char *) begin();
    unsigned char *e = (unsigned char *) end();

    while (b != e)
    {
      *b = tolower_lookup[*b];
      ++b;
    }
  }

  faststring& ToLower()
  {
    tolower();
    return *this;
  }

  void toupper_slow()
  {
    char *b = begin();
    char *e = end();
    
    while (b != e)
    {
      *b = std::toupper(*b);
      ++b;
    }
  }

  // In place toupper
  void toupper()
  {
    unsigned char *b = (unsigned char *) begin();
    unsigned char *e = (unsigned char *) end();
    
    //    char *b = (char *) begin();
    //    char *e = (char *) end();
    
    while (b != e)
    {
      *b = toupper_lookup[*b];
      ++b;
    }
  }

  faststring& ToUpper()
  {
    toupper();
    return *this;
  }
  
  void erase_front(size_type n)
  {
    if (n>0)
    {
      if (n > _len)
      {
        _len = 0;
        return;
      }
      else
      {
        _len -=n;
      }
      memmove(_buf, _buf+n, _len);
    }
  }
  
  void erase_back(size_type n)
  {
    if (n > _len)
      _len = 0;
    else
      _len -= n;
  }

  void erase_all(const CharLookup &cl)
  {
    char *first = begin();
    char *last  = end();

    while (first != last && !cl.check(*first))
      ++first;

    if (first != last)
        for (char *p = first; ++p != last;)
	  if (!(cl.check(*p)))
	      *first++ = *p;
    shorten(first-begin());
  }

  void erase_all(const char *symbols)
  {
    CharLookup cl(0);

    char *first = begin();
    char *last  = end();

    while (*symbols != 0)
      cl.add(*symbols++);

    while (first != last && !cl.check(*first))
      ++first;

    if (first != last)
        for (char *p = first; ++p != last;)
          if (!(cl.check(*p)))
            *first++ = *p;
    shorten(first-begin());
  }
    
  // Shorten string to n characters. If its length is less than n, we append c
  // as often as necessary to get a length of n.
  void resize ( size_type n, char c )
  {
    if (n < _len)
      shorten(n);
    else if (n > _len)
      append(n-_len,c);
  }

  void resize ( size_type n )
  {
    resize(n, char());
  }

  void shorten(size_type new_len)
  {
    _len = macromin(_len, new_len);
  }
  
  void shorten_to_first_occurrence_of(char c)
  {
    size_type pos = find(c,0);
    shorten(pos);
  }

  void shorten_to_first_occurrence_of(const char *symbollist)
  {
    const char *p = symbollist;
    size_type pos;
    while (*p != '\0')
    {
      pos = find(*p,0);
      shorten(pos);
      ++p;
    }
  }
  
  // See also resize for a different version of this function.
  // Appends multiple characters to fill the string if it is shorter than wanted.
  void fill_if_shorter ( size_type n, char c )
  {
    if (n <= _len)
      return;
    append(n-_len,c);
  }
  
  faststring &operator=(const faststring &a)
  {
    _len = a._len;
    
    //    std::cerr << "_len: " << _len << std::endl;
    
    reserve(_len+1);
    memcpy(_buf, a._buf, _len);
    return *this;
  }
  
  friend bool operator==(const faststring &a, const faststring &b)
  {
    if (a._len != b._len)
      return false;
    return (strncmp(a._buf, b._buf, a._len) == 0);
  }
  
  friend bool operator!=(const faststring &a, const faststring &b)
  {
    if (a._len != b._len)
      return true;
    return (strncmp(a._buf, b._buf, a._len) != 0);
  }
  
  // Has been corrected in 03.2011
  friend bool operator<(const faststring &a, const faststring &b)
  {
    size_type l   =  macromin(a._len, b._len );
    //     int res =  (strncmp(a._buf, b._buf, l) < 0);
    short res =  strncmp(a._buf, b._buf, l);
    
    if (res == 0)
      return (a._len < b._len );
    //     return res; // Was wrong in earlier versions.
    return (res < 0);
  }

  friend bool operator<=(const faststring &a, const faststring &b)
  {
    size_type l   =  macromin(a._len, b._len );
    //     int res =  (strncmp(a._buf, b._buf, l) < 0);
    short res =  strncmp(a._buf, b._buf, l);

    if (res == 0)
      return (a._len <= b._len );
    //     return res; // Was wrong in earlier versions.
    return (res < 0);
  }
  
  // Caution: strcmp assumes \0 terminated strings.
  //          Since we do not have \0 terminated strings we
  //          use strncmp with n such that we do not pass the ends
  //          of the strings.
  friend int fstrcmp(const faststring &a, const faststring &b)
  {
    size_type l   =  macromin(a._len, b._len );
    short     res =  strncmp(a._buf, b._buf, l);
    
    if (res == 0)  // We only compared the first l chars.
    {
      if (a._len < b._len)
        return -1;
      if (a._len > b._len)
        return 1;
      return 0;
    }
    return res;
  }
  
  friend int fstrncmp(const faststring &a, const faststring &b, size_type n)
  {
    size_type   l   = macromin(a._len, b._len );
    size_type   m   = macromin(l, n);
    
    short res =  strncmp(a._buf, b._buf, m);
    
    // We do not have \0 terminated strings, so we have to restrict the initial
    // comparison to the length m.
    
    // If n is larger than the length of any of the two strings
    // we need to check the lengths.
    
    if (n <= l)   // If n is smaller or equal to the shorter string, we have a result.
      return res; // This can be <,>, ==
                  // else // if n > l
    
    // In this case, n is larger than one of the two string lengths or larger than both.
    // Still in this case we could have res!=0 among the first m string positions.
    // If res!=0, this is the result.
    
    if (res != 0)
      return res;
    
    // else if res == 0, the two strings are equal among the first m positions
    // and thus they are equal over the whole length of the shorter string.
    
    // If n is larger than both strings, the longer string is greater.
    // If n is larger than only one string, the longer string is greater.
    // => in all cases the shorter string is less.
    //    if lengths are equal, we have to return 0
    
    if (a._len < b._len)
      return -1;
    if (a._len > b._len)
      return 1;
    return 0;
  }
  
  
  // Has been corrected in 03.2011
  friend bool operator>(const faststring &a, const faststring &b)
  {
    size_type l   =  macromin(a._len, b._len );
    //    int res =  (strncmp(a._buf, b._buf, l) > 0);
    short res =  strncmp(a._buf, b._buf, l);
    
    if (res == 0)
      return (a._len > b._len );
    return (res > 0);
  }

  friend bool operator>=(const faststring &a, const faststring &b)
  {
    size_type l   =  macromin(a._len, b._len );
    //    int res =  (strncmp(a._buf, b._buf, l) > 0);
    short res =  strncmp(a._buf, b._buf, l);

    if (res == 0)
      return (a._len >= b._len );
    return (res > 0);
  }

  void removeSpacesFront(const char* delims="\r\n\t\v\f ")
  {
    size_type i;
    
    for (i=0; i < _len && is_in_symbol_list__(_buf[i], delims); ++i)
    {}
    erase_front(i);
  }
  
  
  void removeSpacesBack(const char* delims="\r\n\t\v\f ")
  {
    size_type n_renomve=0;
    
    if (_len > 0)
    {
      for (size_type i=_len-1; is_in_symbol_list__(_buf[i], delims); --i)
      {
        ++n_renomve;
        if (i==0)
          break;
      }
      erase_back(n_renomve);
    }
  }
  
  void removeSpaces(const char* delims="\r\n\t\v\f ")
  {
    char *i, *j, *e;
    e = end();
    i = begin();
    
    // Skip symbols we do not remove
    while (i != e && !is_in_symbol_list__(*i, delims))
      ++i;
    
    if (i == e) // Nothing was done.
      return;
    
    j = i;
    ++i;
    
    while (i != e)
    {
      if (is_in_symbol_list__(*i, delims)) // remove this
      {
        ++i;
      }
      else
      {
        *j = *i;
        ++i;
        ++j;
      }
    }
    _len -= i-j;
  }
  
  
  void remove_symbol(char c)
  {
    char *i, *j, *e;
    e = end();
    i = begin();
    
    // Skip symbols we do not remove
    while (i != e && *i != c)
      ++i;
    
    if (i == e) // Nothing was done.
      return;
    
    j = i;
    ++i;
    
    while (i != e)
    {
      if (*i == c) // remove this
      {
        ++i;
      }
      else
      {
        *j = *i;
        ++i;
        ++j;
      }
    }
    _len -= i-j;
  }
  
  /*
   size_type count_symbol(char sym) const
   {
   size_type res=0;
   const char *pos_it = begin();
   const char *end_it = end();
   
   while (pos_it != end_it)
   {
   if (*pos_it == sym)
   ++res;
   
   ++pos_it;
   }
   return res;
   }
   */
  
  size_type countChar(char sym) const
  {
    size_type res=0;
    const char *pos_it = begin();
    const char *end_it = end();
    
    while (pos_it != end_it)
    {
      if (*pos_it == sym)
        ++res;
      
      ++pos_it;
    }
    return res;
  }
  
  void skip_symbols(size_type &pos, const char* delims="\r\n\t\v\f ") const
  {
    const char *end_it = end();
    const char *pos_it = begin()+pos;
    
    while (pos_it != end_it && is_in_symbol_list__(*pos_it, delims) )
      ++pos_it;
    pos = pos_it-begin();
  }
  
  
  void skip_symbol(size_type &pos, char c) const
  {
    const char *end_it = end();
    const char *pos_it = begin()+pos;
    
    while (pos_it != end_it && *pos_it == c)
      ++pos_it;
    pos = pos_it-begin();
  }
  
  void skip_spaces(size_type &pos) const
  {
    skip_symbols(pos);
  }
  
  void replace_char(char origChar, char newChar)
  {
    char *pos_it = begin();
    const char *end_it = end();
    
    while (pos_it != end_it)
    {
      if (*pos_it == origChar)
        *pos_it = newChar;
      ++pos_it;
    }
  }
  
  size_type replace_char_count(char origChar, char newChar)
  {
    size_type     count  = 0;
    char *pos_it = begin();
    const char *end_it = end();
    
    while (pos_it != end_it)
    {
      if (*pos_it == origChar)
      {
        ++count;
        *pos_it = newChar;
      }
      ++pos_it;
    }
    return count;
  }
  
  // Replace first with second char, third with fourth char, etc.
  void replace_chars(const faststring &replace)
  {
    if (replace.length()%2 != 0)
    {
      return;
    }
    for (size_type i=0; i<replace.length(); i+=2)
    {
      replace_char(replace[i], replace[i+1]);
    }
  }
  
  
  /*----------------------------------------------------------------------------------------------------------------------
   |	Shortens stored string to n - 3 characters, setting the last three characters "...". If string is already <=
   |	n characters in length, this function has no effect. This is useful when it is desirable to show some of the
   |	contents of a string, even when the string will not fit in its entirety into the space available for displaying it.
   |*/
  faststring& ShortenTo(size_type n)
  {
    if (n <= 3 || _len <= n )
      return *this;
    
    // _len > n && n>3 now:
    _len = n;
    _buf[n-1] = '.';
    _buf[n-2] = '.';
    _buf[n-3] = '.';
    return *this;
  }

  // TODO: Use pointers to make this more efficient.
  bool isADouble() const
  {
    size_type i=0;
    
    bool hasDigits    = false;
    bool hasExp       = false;
    bool hasExpDigits = false;
    
    while (i< _len && isspace(_buf[i]))
      ++i;
    
    // I am not sure this line makes it more efficient
    //     if (i >= _len)
    //       return false;
    
    if (i < _len && (_buf[i] == '-' || _buf[i] == '+') )
      ++i;
    
    while (i < _len && isdigit(_buf[i]) )
    {
      ++i;
      hasDigits = true;
    }
    
    if (i < _len && _buf[i] == '.')
      ++i;
    
    while (i < _len && isdigit(_buf[i]) )
    {
      ++i;
      hasDigits = true;
    }

    if ( i < _len && (_buf[i] == 'e' || _buf[i] == 'E') )
    {
      hasExp = true;
      ++i;
    }

    if (i < _len && (_buf[i] == '-' || _buf[i] == '+') )
      ++i;

    while (i < _len && isdigit(_buf[i]) )
    {
      ++i;
      hasExpDigits = true;
    }
    
    while (i < _len && isspace(_buf[i]) )
      ++i;
    
    // We passed all characters that could be interpreted as part of the double number.
    // If we have not reached the end of the string, the string contains characters that are not
    // part of a double number. If this is the case we return false.
    if (i < _len)
      return false;
    
    if (hasDigits)
    {
      if (hasExp && hasExpDigits)
        return true;
      if (!hasExp && !hasExpDigits)
        return true;
      return false;
    }
    else
      return false;
  }
  
  // TODO: Use pointers to make this more efficient.
  bool isAnInt() const
  {
    size_type i=0;
    bool hasDigits = false;
    
    while (i < _len  && _buf[i] == ' ')
      ++i;
    
    if (i < _len && (_buf[i] == '-' || _buf[i] == '+') )
      ++i;
    
    while (i < _len && isdigit(_buf[i]))
    {
      ++i;
      hasDigits = true;
    }
    
    while (i < _len && _buf[i] == ' ')
      ++i;
    
    if (i < _len)
      return false;
    else
      if (hasDigits)
        return true;
      else
        return false;
  }
  
  bool isAnUnsigned() const
  {
    size_type i=0;
    bool hasDigits = false;
    
    while (i < _len && _buf[i] == ' ')
      ++i;
    
    if (i < _len && _buf[i] == '+')
      ++i;
    
    while (i < _len && isdigit(_buf[i]))
    {
      ++i;
      hasDigits = true;
    }
    
    while (i < _len && _buf[i] == ' ')
      ++i;
    
    if (i < _len)
      return false;
    else
      if (hasDigits)
        return true;
      else
        return false;
  }

// Test continue here:

  //---------------------------------------
  // Side effects:  Invalidates pointers.
  //---------------------------------------
  faststring &AddQuotes(char quote_char = '\'')
  {
    reserve(_len + 2);
    memmove(_buf+1, _buf, _len);
    _buf[0]      = quote_char;
    _buf[_len+1] = quote_char;
    _len += 2;
    
    return *this;
  }
  
  void consume(faststring &s)
  {
    _capacity = s._capacity;
    _len      = s._len;
    _buf      = s._buf;
    
    s._buf = NULL;
    s._capacity = s._len = 0;
  }
  
  void swap(faststring &s)
  {
    char       *tmp_buf      = _buf;
    size_type      tmp_len      = _len;
    size_type      tmp_capacity = _capacity;
    
    _buf      = s._buf;
    _len      = s._len;
    _capacity = s._capacity;
    
    s._buf      = tmp_buf;
    s._len      = tmp_len;
    s._capacity = tmp_capacity;
  }
  
  
  faststring &doubleChar(char c)
  {
    faststring tmp;
    
    size_type count_c = countChar(c);
    
    if (count_c > 0)
    {
      tmp.reserve(_len + count_c);
      
      size_type i;
      size_type j;
      for (i=0, j=0; i<_len; ++i, ++j)
      {
        if (c == (tmp._buf[j] = _buf[i]) )
        {
          ++j;
          tmp._buf[j] = _buf[i];
        }
      }
      tmp._len = _len + count_c;
      
      consume(tmp);
    }
    return *this;
  }
  
  /* Rarely used in old projects:
   int PrintF(const char *format, ...)
   {
   char *tmp;
   
   // Create and initialise list of optional arguments:
   va_list argList;
   
   #if !defined (WIN32) && !defined (_WIN64)
   va_start(argList, format);
   int N = vasprintf(&tmp, format, argList);
   va_end(argList);
   #else // In case we are on a WIN32 or _WIN64 machine
   va_start(argList, format);
   tmp = new char [5000];
   int N = vsnprintf(tmp, 5000, format, argList);
   va_end(argList);
   #endif
   _buf = tmp;
   _capacity = N+1;
   _len = N;
   return N;
   }
   */
  
  // Convert to unsigned long
  unsigned ToUnsigned()
  {
    char *end;
    return (unsigned)strtoul(c_str(), &end, 0); // There is no system strtou without l, so we use strtoul
  }
  
  // Make sure you check errno yourself
  unsigned	ToUnsigned(size_type  beg_pos,
                       size_type& end_pos)
  {
    const char     *beg = c_str()+beg_pos;
    char     *end;
    unsigned result;
    
    //     errno = 0;
    result  = (unsigned)strtoul(beg, &end, 0);
    //     if (errno != 0)
    //     {
    //       std::cerr << "Parse error in ToUnsigned." << std::endl;
    //     }
    end_pos = end-begin_str();
    return result;
  }
  
  
  
  // Convert to unsigned long
  unsigned long ToUnsignedLong()
  {
    char *end;
    return strtoul(c_str(), &end, 0);
  }
  
  // Convert to int
  int ToInt()
  {
    char *end;
    return (int) strtol(c_str(), &end, 0);
  }
  
  // Convert to long
  long ToLong()
  {
    char *end;
    return strtol(c_str(), &end, 0);
  }
  
  long	ToLong(size_type  beg_pos,
               size_type& end_pos)
  {
    const char   *beg = c_str()+beg_pos;
    char   *end;
    long   result;
    
    result  = strtol(beg, &end, 0);
    end_pos = end-c_str();
    return result;
  }
  
  
  // Convert to double
  double ToDouble()
  {
    char *end;
    return strtod(c_str(), &end);
  }
  
  double ToDouble(size_type  beg_pos,
                  size_type& end_pos)
  {
    const char   *beg = c_str()+beg_pos;
    char   *end;
    double result;
    
    result  = strtod(beg, &end);
    end_pos = end-c_str();
    return result;
  }
  
  double ToDouble(size_type pos,
                  char **end)
  {
    double result;
    
    result  = strtod(_buf+pos, end);
    return result;
  }

  unsigned extractFirstUnsigned() const
  {
    unsigned number = 0;
    bool foundDigit = false;

    size_type pos = find_first_of("0123456789",0);

    if (pos == npos)
      return UINT_MAX;

    for (; pos<_len; ++pos)
    {
      char c = _buf[pos];
      if (std::isdigit(c))
      {
        number = number * 10 + (c - '0');
        foundDigit = true;
      }
      else
        if (foundDigit)
          break;
    }
    return number;
  }

  bool EqualsCaseSensitive(const faststring &s)
  {
    if (_len != s._len)
      return false;
    
    return (strncmp(_buf, s._buf, _len) == 0);
  }
  
  bool EqualsCaseInsensitive(const faststring &s) const
  {
    if (_len != s._len)
      return false;
    
    faststring a(*this);
    faststring b(s);
    
    a.tolower();
    b.tolower();
    
    return (strncmp(a._buf, b._buf, _len) == 0);
  }
  
  //=================================================
  // The family of compare functions:
  //=================================================
  // int compare ( const string& str ) const;
  // int compare ( const char* s ) const;
  // int compare ( size_type pos1, size_type n1, const string& str ) const;
  // int compare ( size_type pos1, size_type n1, const char* s) const;
  // int compare ( size_type pos1, size_type n1, const string& str, size_type pos2, size_type n2 ) const;
  // int compare ( size_type pos1, size_type n1, const char* s, size_type n2) const;
  // ------------------------------------------------- all implemented
  
  // Result: >: +1, <: -1, == 0
  int compare(const faststring &s)
  {
    size_type l = macromin(_len, s._len);
    int    res = strncmp(_buf, s._buf, l);
    
    if (res != 0)
      return res;
    
    if (_len == s._len)
      return 0;
    else
      return (int)(_len > s._len);
  }
  
  // Result: >: +1, <: -1, == 0
  int compare(const char *s)
  {
    size_type   s_len = strlen(s);
    size_type   l     = macromin(_len, s_len);
    int      res   = strncmp(_buf, s, l);
    
    if (res != 0)
      return res;
    
    if (_len == s_len)
      return 0;
    else
      return (int)(_len > s_len);
  }
  
  
  // Result: >: +1, <: -1, == 0
  int compare(const char *t1, const char*t2, const char *s1, const char *s2)
  {
    // Out of range check:
    if (t1 > t2 || s1 > s2)
      return -2;
    
    if (t1 < _buf || t2 > _buf+_len)
      return -3;
    
    return compare_unchecked(t1,t2, s1, s2);
  }
  
  
  int compare ( size_type pos1, size_type n1, const faststring& str ) const
  {
    if (pos1 > _len || pos1 + n1 > _len)
      return -3;
    
    return compare_unchecked(_buf+pos1, _buf+pos1+n1, str._buf, str._buf+str._len);
  }
  
  int compare ( size_type pos1, size_type n1, const char* s) const
  {
    if (pos1 > _len || pos1 + n1 > _len)
      return -3;
    
    const char *e = s + strlen(s);
    
    return compare_unchecked(_buf+pos1, _buf+pos1+n1, s, e);
  }
  
  int compare ( size_type pos1, size_type n1, const faststring& str, size_type pos2, size_type n2 ) const
  {
    if (pos1 > _len || pos1 + n1 > _len)
      return -3;
    if (pos2 > str._len || pos2 + n2 > str._len)
      return -4;
    
    return compare_unchecked(_buf+pos1, _buf+pos1+n1, str._buf+pos2, str._buf+pos2+n2);
  }
  
  int compare ( size_type pos1, size_type n1, const char* s, size_type n2) const
  {
    size_type s_len = strlen(s);
    
    if (pos1 > _len || pos1 + n1 > _len)
      return -3;
    if (n2 > s_len)
      return -4;
    
    return compare_unchecked(_buf+pos1, _buf+pos1+n1, s, s+n2);
  }
  
  
  // Result: >: +1, <: -1, == 0
  int compare_unchecked(const char *t1, const char*t2, const char *s1, const char *s2) const
  {
    size_type t_len = t2-t1;
    size_type s_len = s2-s1;
    
    size_type l = macromin(t_len, s_len);
    int    res = strncmp(t1, s1, l);
    
    if (res != 0)
      return res;
    
    if (t_len == s_len)
      return 0;
    else
      return (int)(t_len > s_len);
  }
  
  
  unsigned char * p_str(unsigned char *buffer) const //
  {
    if (_len > 255)
    {
      *buffer = '\0';
      return 0;
    }
    
    memcpy(buffer+1, _buf, _len);
    buffer[0] = (unsigned char)_len;
    return buffer;
  }
  
  void AsBinary(unsigned long l)
  {
    short bits = sizeof(l)*8;
    reserve(bits);
    _len = bits;
    
    short i;
    for (i=(short)_len-1; i >= 0; --i)
    {
      // is l odd
      _buf[i] = (char)((char)(l%2)+'0');
      l/=2;
    }
  }
  
  void AsBinary(unsigned long l, unsigned digits)
  {
    reserve(digits);
    _len = digits;
    
    short i;
    for (i=(short)_len-1; i >= 0; --i)
    {
      // is l odd
      _buf[i] = (char)((char)(l%2)+'0');
      l/=2;
    }
  }
  
  
  void AsHex(unsigned long l)
  {
    short hexes = sizeof(l)*2;
    char remainder;
    
    reserve(hexes);
    _len = hexes;
    
    short i;
    for (i=(short)_len-1; i >= 0; --i)
    {
      remainder = l%16;
      
      if (remainder < 10)
        _buf[i] = remainder+'0';
      else
      {
        _buf[i] = remainder+55;
      }
      l /= 16;
    }
  }
  
  void AsHex(unsigned long l, unsigned digits)
  {
    char remainder;
    
    reserve(digits);
    _len = digits;
    
    short i;
    for (i=(short)_len-1; i >= 0; --i)
    {
      remainder = l%16;
      
      if (remainder < 10)
        _buf[i] = remainder+'0';
      else
      {
        _buf[i] = remainder+55;
      }
      l /= 16;
    }
  }
  
  faststring substr(size_type pos, size_type n=npos) const
  {
    const char * b = _buf+pos;
    const char * e = _buf+pos+n;
    
    if (b > _buf+_len)
      b = _buf+_len;
    
    if (n==npos || e > _buf+_len)
    {
      e = _buf+_len;
    }
    
    faststring res(b, e);
    return res;
  }
  
  faststring substr(const char *b, const char * e) const  // This function just calls the constructor, but contrary to this can check the validity of the range.
  {
    if (b > _buf+_len)
      b = _buf+_len;
    if (e > _buf+_len)
      e = _buf+_len;
    
    faststring res(b, e);
    return res;
  }
  
  //=================================================
  // The family of erase functions:
  //=================================================
  // string& erase ( size_type pos = 0, size_type n = npos );
  // iterator erase ( iterator position );
  // iterator erase ( iterator first, iterator last );
  // ------------------------------------------------- all implemented
  
  faststring &erase ( size_type pos, size_type n = npos )
  {
    char *p1 = _buf+pos;
    char *p2 = _buf+pos+n;
    
    if (p1 >  _buf+_len)
      p1 = _buf+_len;
    
    if (n==npos || p2 > _buf+_len)
      p2 = _buf+_len;
    
    return erase(p1, p2);
  }
  
  faststring &erase ( char *p1)
  {
    return erase(p1, p1+1);
  }
  
  faststring &erase ( char *p1, char *p2 )
  {
    char *tmp1 = p1;
    char *tmp2 = p2;
    char *e    = _buf + _len;
    
    if (p1 >= p2)
      return *this;
    
    if (p1 < _buf)
      p1 = _buf;
    
    if (p2 > e)
      p2 = e;
    
    // Copy chars to the left within the string.
    while (tmp2 < e)
    {
      *tmp1 = *tmp2;
      ++tmp1;
      ++tmp2;
    }
    
    // Reduce length
    _len -= (p2-p1);
    
    return *this;
  }
  
  void erase()
  {
    _len = 0;
  }
  
  void clear()
  {
    _len = 0;
  }
  
  void reset()
  {
    if (_buf)
    {
      free(_buf);
      _buf = NULL;
      _capacity = 0;
      _len = 0;
    }
  }
  
  //=================================================
  // The family of insert functions:
  //=================================================
  // - string& insert ( size_type pos1, const string& str );
  // - string& insert ( size_type pos1, const string& str, size_type pos2, size_type n );
  // - string& insert ( size_type pos1, const char* s, size_type n);
  // - string& insert ( size_type pos1, const char* s );
  // - string& insert ( size_type pos1, size_type n, char c );
  // - iterator insert ( iterator p, char c );
  // - void insert ( iterator p, size_type n, char c );
  //=================================================
  
  //---------------------------------------
  // Side effects:  Invalidates pointers.
  //---------------------------------------
  faststring &insert(size_type pos, const char *p1, const char *p2)
  {
    if (pos > _len || p1 >= p2)
      return *this;
    
    
    size_type N = p2-p1; // Number of characters to be inserted
    reserve(_len+N);
    
    //     char *b    = _buf;
    char *e    = _buf+_len; // This is still the old _len. We have reserved new space but we have not used it yet.
    char *tmp  = e-1;       // Pointer to the last char. We start at the last char which we move first.
    char *tmpN = tmp+N;
    
    // Now, after having reserved new memory, we can work with pointers in _buf
    // again.
    
    char *p_pos = _buf + pos;
    
    // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    
    // Create the space needed:
    while (tmp >= p_pos )
    {
      *tmpN = *tmp;
      --tmp;
      --tmpN;
    }
    //     *tmpN = *tmp;
    _len += N;
    
    replace_intern(p_pos, p1, p2);
    return *this;
  }
  
  faststring &insert(char *p_pos, const char *p1, const char *p2)
  {
    return insert(p_pos-_buf, p1, p2);
  }
  
  
  faststring &insert(size_type pos1, const faststring &str)
  {
    return insert(pos1, str.begin(), str.end());
  }
  
  faststring& insert ( size_type pos1, const faststring& str, size_type pos2, size_type n )
  {
    char *b = str._buf + pos2;
    char *e = str._buf + pos2+n;
    
    if (b > str.end() || e > str.end() )
      return *this;
    
    return insert(pos1, b, e);
  }
  
  
  faststring& insert ( size_type pos1, const char* s, size_type n)
  {
    size_type s_len = strlen(s);
    
    if (s_len < n)
      return *this;
    
    return insert(pos1, s, s+n);
  }
  
  faststring& insert( size_type pos1, const char* s)
  {
    size_type s_len = strlen(s);
    
    return insert(pos1, s, s+s_len);
  }
  
  faststring& insert( size_type pos1, size_type n, char c )
  {
    faststring str(n, c);
    
    return insert(pos1, str.begin(), str.end() );
  }
  
  faststring& insert( size_type pos1, char c )
  {
    return insert(pos1, &c, &c+1 );
  }
  
  faststring& insert( char *p, size_type n, char c )
  {
    faststring str(n, c);
    
    return insert(p-_buf, str.begin(), str.end() );
  }
  
  char* insert( char *p, char c )
  {
    insert(p-_buf, &c, &c+1 );
    return p;
  }
  
  
  //=================================================
  // The family of replace functions:
  //=================================================
  // - string& replace ( size_type pos1, size_type n1,   const string& str );
  // - string& replace ( iterator i1, iterator i2, const string& str );
  // - string& replace ( size_type pos1, size_type n1, const string& str, size_type pos2, size_type n2 );
  // - string& replace ( size_type pos1, size_type n1, const char* s, size_type n2 );
  // - string& replace ( iterator i1, iterator i2, const char* s, size_type n2 );
  // - string& replace ( size_type pos1, size_type n1,   const char* s );
  // - string& replace ( iterator i1, iterator i2, const char* s );
  // - string& replace ( size_type pos1, size_type n1,   size_type n2, char c );
  // - string& replace ( iterator i1, iterator i2, size_type n2, char c );
  // - template<class InputIterator> string& replace ( iterator i1, iterator i2, InputIterator j1, InputIterator j2 );
  
  // replace_intern assumes that ranges have already been checked!!!
  // This simple version does no error checking and simply overwrites
  // part of the this object.
  void replace_intern(char *t1, const char *p1, const char *p2)
  {
    while (p1 < p2)
    {
      *t1 = *p1;
      ++t1;
      ++p1;
    }
  }
  
  
  //TODO: test
  // Overwrite range must "fit" into target string.
  // Otherwise, nothing is done.
  void overwrite(char *t1, char *p1, char *p2)
  {
    size_type N = p2-p1;
    
    if (t1 < _buf || t1+N > _buf+_len)
      return;
    
    replace_intern(t1, p1, p2);
  }
  
  // erases the range from pos1 to pos1+n1 and then inserts str
  // if pos1 is not a valid position in the string, nothing will be done.
  
  faststring& replace ( size_type pos1, size_type n1,   const faststring& str )
  {
    if (pos1 > _len)
      return *this;
    
    // Number of chars we want/can to "remove":
    size_type real_n1 = macromin(n1, _len-pos1);
    
    replace_unchecked (_buf+pos1, _buf+pos1 + real_n1, str.begin(), str.length() );
    
    return *this;
  }
  
  faststring& replace ( char *i1, char *i2, const faststring& str )
  {
    if (i1 < _buf || i2 > _buf+_len)
      return *this;
    
    replace_unchecked(i1, i2, str.begin(), str.length() );
    return *this;
  }
  
  faststring& replace ( size_type pos1, size_type n1, const faststring& str, size_type pos2, size_type n2 )
  {
    if (pos1 >= _len)
      return *this;
    
    if (pos2 >= str._len)
      return *this;
    
    // Number of chars we can "remove":
    size_type real_n1 = macromin(n1, _len-pos1);
    
    // Number of chars we can "insert":
    size_type real_n2 = macromin(n2, str._len-pos2);
    
    replace_unchecked(_buf+pos1,_buf+pos1+real_n1, str.begin()+pos2, real_n2);
    
    return *this;
  }
  
  faststring& replace ( size_type pos1, size_type n1,   const char* s, size_type n2 )
  {
    if (pos1 >= _len)
      return *this;
    
    size_type s_len = strlen(s);
    
    //     if (n2 <= s_len )
    //      return *this;
    
    // Number of chars we can "remove":
    size_type real_n1 = macromin(n1, _len-pos1);
    
    // Number of chars we can "insert":
    size_type real_n2 = macromin(n2, s_len);
    
    replace_unchecked(_buf+pos1,_buf+pos1+real_n1, s, real_n2);
    
    return *this;
  }
  
  faststring& replace ( char *i1, char *i2, const char* s, size_type n2 )
  {
    if (i1 < _buf     || i2 > _buf+_len)
      return *this;
    
    size_type s_len = strlen(s);
    
    if (n2 > s_len)
      n2 = s_len;
    
    replace_unchecked (i1, i2, s, n2);
    return *this;
  }
  
  faststring& replace(char *i1, char *i2, const char* s1, const char * s2)
  {
    if (i1 < _buf     || i2 > _buf+_len || s2 < s1)
      return *this;
    
    replace_unchecked (i1, i2, s1, s2-s1);
    return *this;
    
  }
  
  void replace_unchecked ( char *i1, char *i2, const char* s, size_type n2 )
  {
    // Number of chars we want/can to "remove":
    size_type n_remove = i2-i1;
    
    // Number of chars we want to insert:
    size_type n_insert = n2;
    
    if (n_remove == n_insert) // simple overwrite:
    {
      replace_intern(i1, s, s+n_insert);
    }
    else if (n_remove > n_insert) // We have too much space and need to erase some characters.
    {
      erase(i1, i1+n_remove - n_insert);
      replace_intern(i1, s, s+n_insert);
    }
    else	   // We have too little space and need to insert some characters.
    {
      size_type n_newspace = n_insert-n_remove;
      
      insert(i1-_buf, s, s + n_newspace);
      replace_intern(i1 + n_newspace, s+n_newspace, s+n_insert);
    }
  }
  
  faststring& replace ( size_type pos1, size_type n1,   const char* s )
  {
    if (pos1 >= _len)
      return *this;
    
    size_type s_len = strlen(s);
    
    //     if (n2 <= s_len )
    //      return *this;
    
    // Number of chars we can "remove":
    size_type real_n1 = macromin(n1, _len-pos1);
    
    // Number of chars we can "insert":
    size_type real_n2 = s_len;
    
    replace_unchecked(_buf+pos1,_buf+pos1+real_n1, s, real_n2);
    
    return *this;
  }
  
  faststring& replace ( char *i1, char *i2, const char* s )
  {
    if (i1 < _buf || i2 > _buf+_len)
      return *this;
    
    size_type s_len = strlen(s);
    
    replace_unchecked(i1, i2, s, s_len);
    
    return *this;
  }
  
  faststring& replace ( size_type pos1, size_type n1, size_type n2, char c )
  {
    if (pos1 >= _len)
      return *this;
    
    size_type real_n1 = macromin(n1, _len-pos1);
    
    faststring tmp(n2, c);
    
    replace_unchecked(_buf+pos1, _buf+pos1+real_n1, tmp.begin(), n2);
    
    return *this;
  }
  
  faststring& replace ( char *i1, char *i2, size_type n2, char c )
  {
    if (i1 < _buf || i2 > _buf+_len)
      return *this;
    
    faststring tmp(n2, c);
    
    replace_unchecked(i1, i2, tmp.begin(), n2);
    
    return *this;
  }
  
  //=================================================
  
  

  char & operator[](size_type i)
  {
    return _buf[i];
  }
  
  char operator[](size_type i) const
  {
    return _buf[i];
  }
  
  size_type copy ( char* s, size_type n, size_type pos = 0) const
  {
    if (pos > _len)
      return -2;
    
    size_type l = n;
    if (n+pos > _len)
      l = _len-pos;
    
    memcpy(s, _buf+pos, l);
    
    return l;
  }
  
  //=================================================
  // The family of find functions:
  //=================================================
  // size_type find ( const string& str, size_type pos = 0 ) const;
  // size_type find ( const char* s, size_type pos, size_type n ) const;
  // size_type find ( const char* s, size_type pos = 0 ) const;
  // size_type find ( char c, size_type pos = 0 ) const;
  
  size_type find ( const faststring& str, size_type pos = 0 ) const
  {
    const char *p = find_fundamental(begin()+pos, end(), str.begin(), str.end() );
    
    if (p != NULL)
      return p-begin();
    else
      return npos;
  }
  
  size_type find ( const char* s, size_type pos, size_type n ) const
  {
    const char *p = find_fundamental(begin()+pos, end(), s, s+n );
    
    if (p != NULL)
      return p-begin();
    else
      return npos;
  }
  
  size_type find ( const char* s, size_type pos=0) const
  {
    const char *p = find_fundamental(begin()+pos, end(), s, s+strlen(s) );
    
    if (p != NULL)
      return p-begin();
    else
      return npos;
  }
  
  // There is one good reason determining the position and not the pointer:
  // - The position is still valid after a realloc, the pointer is not.
  size_type find(char c, size_type pos=0) const
  {
    char *b = begin()+pos;
    char *e = end();
    
    while (b < e && *b != c)
      ++b;
    if (b == e)
      return npos;
    else
      return b-begin();
  }
  
  /*   size_type find_forward(char c, size_type pos=0) const */
  /*   { */
  /*     char *b = begin()+pos; */
  /*     char *e = end(); */
  
  /*     while (b < e && *b != c) */
  /*       ++b; */
  /*     if (b >= e) */
  /*       return -1u; */
  /*     else */
  /*       return b-begin(); */
  /*   } */
  
  
  //=================================================
  // The family of rfind functions:
  //=================================================
  // size_type rfind ( const string& str, size_type pos = npos ) const;
  // size_type rfind ( const char* s, size_type pos, size_type n ) const;
  // size_type rfind ( const char* s, size_type pos = npos ) const;
  // size_type rfind ( char c, size_type pos = npos ) const;
  
  size_type rfind ( const faststring& str, size_type pos = npos ) const
  {
    if (pos >= _len)
      pos = _len-1;
    
    const char *p = rfind_fundamental(begin()+pos,rend(),str.rbegin(),str.rend());
    
    if (p != NULL)
      return p-begin();
    else
      return npos;
  }
  
  size_type rfind ( const char* s, size_type pos, size_type n ) const
  {
    if (pos >= _len)
      pos = _len-1;
    
    const char *p = rfind_fundamental(begin()+pos, rend(), s+n-1, s-1 );
    
    if (p != NULL)
      return p-begin();
    else
      return npos;
  }
  
  size_type rfind ( const char* s, size_type pos=npos) const
  {
    if (pos >= _len)
      pos = _len-1;
    
    const char *p = rfind_fundamental(begin()+pos, rend(), s+strlen(s)-1, s-1 );
    
    if (p != NULL)
      return p-begin();
    else
      return npos;
  }
  
  size_type rfind(char c, size_type pos=npos) const
  {
    if  (pos >= _len)
      pos = _len-1;
    
    char *b = begin()+pos;
    char *e = begin()-1;
    
    while (b > e && *b != c)
      --b;
    if (b == e) // should be == if nothing was found
      return npos;
    else       // should be b > e if char was found
      return b-begin();
  }
  
  
  //=================================================
  // The family of find_first_of functions:
  //=================================================
  /* size_type find_first_of ( const string& str, size_type pos = 0 ) const; */
  /* size_type find_first_of ( const char* s, size_type pos, size_type n ) const; */
  /* size_type find_first_of ( const char* s, size_type pos = 0 ) const; */
  /* size_type find_first_of ( char c, size_type pos = 0 ) const; */
  
  /* Consider the strcspn function here */
  
  size_type find_first_of( const faststring& str, size_type pos = 0 ) const
  {
    const char *b = begin()+pos;
    const char *e = end();
    
    while (b < e)
    {
      if (is_in_symbol_list__(*b, str.begin(), str.length() ))
        return b-begin();
      ++b;
    }
    return npos;
  }
  
  size_type find_first_of( const char *str, size_type pos, size_type n ) const
  {
    const char *b = begin()+pos;
    const char *e = end();
    
    while (b < e)
    {
      if (is_in_symbol_list__(*b, str, n))
        return b-begin();
      ++b;
    }
    return npos;
  }
  
  size_type find_first_of( const char *str, size_type pos = 0 ) const
  {
    const char *b = begin()+pos;
    const char *e = end();
    
    while (b < e)
    {
      if (is_in_symbol_list__(*b, str) )
        return b-begin();
      ++b;
    }
    return npos;
  }
  
  size_type find_first_of ( char c, size_type pos = 0 ) const
  {
    return find(c, pos);
  }
  
  //=================================================
  // The family of find_last_of functions:
  //=================================================
  /* size_type find_last_of ( const string& str, size_type pos = npos ) const; */
  /* size_type find_last_of ( const char* s, size_type pos, size_type n ) const; */
  /* size_type find_last_of ( const char* s, size_type pos = npos ) const; */
  /* size_type find_last_of ( char c, size_type pos = npos ) const; */
  
  size_type find_last_of( const faststring& str, size_type pos = npos ) const
  {
    if (pos > _len)
      pos = _len;
    
    const char *e = begin()-1;
    const char *b = begin()+pos-1;
    
    while (b > e)
    {
      if (is_in_symbol_list__(*b, str.begin(), str.length() ) )
        return b-begin();
      --b;
    }
    return npos;
  }
  
  
  size_type find_last_of( const char *str, size_type pos, size_type n ) const
  {
    if (pos > _len)
      pos = _len;
    
    const char *e = begin()-1;
    const char *b = begin()+pos-1;
    
    while (b > e)
    {
      if (is_in_symbol_list__(*b, str, n))
        return b-begin();
      --b;
    }
    return npos;
  }
  
  
  size_type find_last_of( const char *str, size_type pos = npos ) const
  {
    if (pos > _len)
      pos = _len;
    
    const char *e = begin()-1;
    const char *b = begin()+pos-1;
    
    while (b > e)
    {
      if (is_in_symbol_list__(*b, str))
        return b-begin();
      --b;
    }
    return npos;
  }
  
  size_type find_last_of ( char c, size_type pos = npos ) const
  {
    return rfind(c, pos);
  }
  
  //=================================================
  // The family of find_first_not_of functions:
  //=================================================
  /* size_type find_first_not_of ( const string& str, size_type pos = 0 ) const; */
  /* size_type find_first_not_of ( const char* s, size_type pos, size_type n ) const; */
  /* size_type find_first_not_of ( const char* s, size_type pos = 0 ) const; */
  /* size_type find_first_not_of ( char c, size_type pos = 0 ) const; */
  
  /* Also consider the strspn function for the implementation !!!!!!!!! */
  
  size_type find_first_not_of( const faststring& str, size_type pos = 0 ) const
  {
    const char *b = begin()+pos;
    const char *e = end();
    
    while (b < e)
    {
      if (!is_in_symbol_list__(*b, str.begin(), str.length() ))
        return b-begin();
      ++b;
    }
    return npos;
  }
  
  size_type find_first_not_of( const char *str, size_type pos, size_type n ) const
  {
    const char *b = begin()+pos;
    const char *e = end();
    
    while (b < e)
    {
      if (!is_in_symbol_list__(*b, str, n))
        return b-begin();
      ++b;
    }
    return npos;
  }
  
  size_type find_first_not_of( const char *str, size_type pos = 0 ) const
  {
    const char *b = begin()+pos;
    const char *e = end();
    
    while (b < e)
    {
      if (!is_in_symbol_list__(*b, str))
        return b-begin();
      ++b;
    }
    return npos;
  }
  
  size_type find_first_not_of ( char c, size_type pos = 0 ) const
  {
    const char *b = begin()+pos;
    const char *e = end();
    
    while (b < e)
    {
      if (*b != c)
        return b-begin();
      ++b;
    }
    return npos;
  }
  
  //=================================================
  // The family of find_last_not_of functions:
  //=================================================
  /* size_type find_last_not_of ( const string& str, size_type pos = npos ) const; */
  /* size_type find_last_not_of ( const char* s, size_type pos, size_type n ) const; */
  /* size_type find_last_not_of ( const char* s, size_type pos = npos ) const; */
  /* size_type find_last_not_of ( char c, size_type pos = npos ) const; */
  
  size_type find_last_not_of( const faststring& str, size_type pos = npos ) const
  {
    if (pos > _len)
      pos = _len;
    
    const char *e = begin()-1;
    const char *b = begin()+pos-1;
    
    while (b > e)
    {
      if (!is_in_symbol_list__(*b, str.begin(), str.length() ))
        return b-begin();
      --b;
    }
    return npos;
  }
  
  
  size_type find_last_not_of( const char *str, size_type pos, size_type n ) const
  {
    if (pos > _len)
      pos = _len;
    
    const char *e = begin()-1;
    const char *b = begin()+pos-1;
    
    while (b > e)
    {
      if (!is_in_symbol_list__(*b, str, n))
        return b-begin();
      --b;
    }
    return npos;
  }
  
  
  size_type find_last_not_of( const char *str, size_type pos = npos ) const
  {
    if (pos > _len)
      pos = _len;
    
    const char *e = begin()-1;
    const char *b = begin()+pos-1;
    
    while (b > e)
    {
      if (!is_in_symbol_list__(*b, str))
        return b-begin();
      --b;
    }
    return npos;
  }
  
  size_type find_last_not_of ( char c, size_type pos = npos ) const
  {
    if (pos > _len)
      pos = _len;
    
    const char *e = begin()-1;
    const char *b = begin()+pos-1;
    
    while (b > e)
    {
      if (*b != c)
        return b-begin();
      --b;
    }
    return npos;
  }
  
  void collapse_mono_symbol_repeats(char c)
  {
    faststring tmp;
    
    const char *p1, *p2;
    p2 = p1 = begin();
    ++p2;
    
    while (p2 != end() )
    {
      if (*p1 != *p2 || *p1 != c)
        tmp.push_back(*p1);
      p1 = p2;
      ++p2;
    }
    // When leaving the loop there is one character remaining that we need to append to tmp:
    tmp.push_back(*p1);
    swap(tmp);
  }
  
  void unquote()
  {
    removeSpacesBack();
    removeSpacesFront();
    if (*begin() == '\"' && *(end()-1) == '\"' )
    {
      this->erase_front(1);
      this->erase_back(1);
      
      /*      this->erase(begin()); */
      /*      this->erase(end()-1); */
    }
    else if (*begin() == '\'' && *(end()-1) == '\'' )
    {
      /*        this->erase(begin()); */
      /*        this->erase(end()-1); */
      
      this->erase_front(1);
      this->erase_back(1);
    }
  }
  
  // Unquote string with first char s and last char e
  void unquote(char s, char e)
  {
    removeSpacesBack();
    removeSpacesFront();
    if (*begin() == s && *(end()-1) == e )
    {
      this->erase_front(1);
      this->erase_back(1);
    }
  }
  
  
  
  bool is_CAPITALIZED_abbreviation_of(const faststring &keyword) const
  {
    size_type i   = 0;
    size_type max = size();
    
    // max cannot be greater than keyword.size()
    if ( max > keyword.size() )
      return false;
    
    // We start comparison in upper case region. Lets see how far we can go.
    while (i < max && std::toupper( _buf[i] ) == keyword[i] )
    {
      ++i;
    }
    
    // First we check whether both strings have the same length and we matched all chars.
    // This means that we matched exactly the upper case region of keyword, which is the
    // complete keyword.
    if ( i == max && max == keyword.size() )
      return true;
    
    // If we get here, i must be smaller than keyword.size() since we can only have
    // * i == max and i == keyword.size(): Not possible after previous if
    // * i <  max and i == keyword.size(): Not possible since max <= keyword.size()
    // * i == max and i < keyword.size():
    // * i <  max and i < keyword.size():
    
    // Thus, keyword[i] is valid and we use it to check whether we are in the upper case region
    // (were all !alpha() should also be considered as upper case chars in this context!!).
    // We simply check whether we are in the !islower() region.
    
    if ( !islower( keyword[i]) )    // We are still in non-lower case region
      return false;
    
    // If we get here, we are in the in the lower-case region
    // There are two possibilities:
    // - i == max,
    if (i==max)
      return true;
    // - our string is longer than the upper case region, so we have to continue
    //   our comparison.
    
    // Let us move through lower case region
    while (i < max && ((*this)[i] == keyword[i] || std::tolower(_buf[i]) == keyword[i]) )
      ++i;
    
    // Could we match all letters in str?
    if (i==max)
      return true;
    else
      return false;
  }
  
  // get the next token and remove it from the called object.
  faststring& get_next_token(faststring &str, const char * ws = "\r\n\t\v\f ")
  {
    const size_type  n = size();
    size_type  i = 0;
    
    str.clear();
    
    // eat leading whitespace/delimiter -- this should be more efficient than
    // calling removeSpacesFront since we only need to erase in the front of the string once.
    while ( (i < n) && ( is_in_symbol_list__( (*this)[i], ws)) ) ++i;
    
    if (i == n)   // nothing left so re remove all spaces and the string will be empty
    {
      erase();
    }
    else
    {
      // find end of word
      size_type  j = i+1;
      while ( (j < n) && (!is_in_symbol_list__( (*this)[j], ws)) ) ++j;
      
      str = substr(i, j);   // the next token
      erase(0, j);                 // remove token from called object
    }
    
    return *this;
  }
  
  void set_to_string_with_values(std::vector<double> v, faststring delim= " ", int precision=14)
  {
    size_type n=v.size();
    clear();
    
    if (n == 0)
      return;
    
    append(faststring(v[0], precision));
    removeSpacesBack();
    
    for (size_type i=1; i<n; ++i)
    {
      append(delim);
      append(faststring(v[i], precision));
      removeSpacesBack();
    }
  }
  
  void set_to_string_with_values(std::vector<int> v, faststring delim= " ")
  {
    size_type n=v.size();
    clear();
    
    if (n == 0)
      return;
    
    append(faststring(v[0]));
    removeSpacesBack();
    
    for (size_type i=1; i<n; ++i)
    {
      append(delim);
      append(faststring(v[i]));
      removeSpacesBack();
    }
  }
  
  void set_to_string_with_values(std::vector<unsigned> v, faststring delim= " ")
  {
    size_type n=v.size();
    clear();
    
    if (n == 0)
      return;
    
    append(faststring(v[0]));
    removeSpacesBack();
    
    for (size_type i=1; i<n; ++i)
    {
      append(delim);
      append(faststring(v[i]));
      removeSpacesBack();
    }
  }
  
  
  // Could be made more efficient.
  // A delimiter could be given as parameter.
  int get_vector_of_values(std::vector<double> &v)
  {
    int bad_values=0;
    v.clear();
    
    std::vector<faststring> vs;
    split(vs, *this);

    for(size_type i=0; i<vs.size(); ++i)
    {
      if (vs[i].isADouble() )
        v.push_back(vs[i].ToDouble());
      else
        ++bad_values;
    }
    return bad_values;
  }
  
  // Funktioniert noch nicht richtig:
  /*  void search_replace_first(faststring s1, faststring s2, unsigned pos=0) */
  /*  { */
  /*    unsigned find_pos = find(s1, pos); */
  
  /*    std::cerr << "find_pos: " << find_pos << std::endl; */
  /*    std::cerr << "s1.length(): " <<  s1.length()  << std::endl; */
  
  
  /*    if (find_pos != npos) */
  /*      replace(find_pos, s1.length(), s2 ); */
  /*  } */
  
  void search_replace_all(faststring s1, faststring s2)
  {
    std::vector<faststring> v;
    split_at(v, *this, s1);
    
    size_type i, N=v.size();
    faststring res;
    
    if (N==1)
      return;  // Just for efficiency. Otherwise we would copy the string v[0] back to this.
    
    for (i=0; i<(N-1); ++i)
    {
      res += v[i];
      res += s2;
    }
    res += v[i];
    
    *this = res;
  }
  
  
  
};

inline std::ostream &operator<<(std::ostream &out, faststring  &str)
{
  out << str.c_str();
  return out;
}

inline std::ostream &operator<<(std::ostream &out, const faststring  &str)
{
  faststring fs = str;
  out << fs.c_str();
  return out;
}


/* This old version caused a warning in append:
 warning: 'void* memcpy(void*, const void*, size_t)' specified size 18446744073709551611 exceeds maximum object size 9223372036854775807 [-Wstringop-overflow=]
 memcpy(_buf+old_len, s._buf, s_len);
inline faststring operator+(const faststring &a, const faststring &b)
{
  faststring res;
  res.reserve(a.size() + b.size());
  res.append(a);
  res.append(b);
  //  a += b;
  return res;
}
 */

inline faststring operator+(const faststring &a, const faststring &b)
{
  faststring res(a);           // copy-construct from a
  res.reserve(a.size() + b.size());  // pre-allocate final size
  res.append(b);               // append only b
  return res;
}



inline std::istream &getline(std::istream &is, faststring &str)
{
  int c;
  
  str.clear();
  
  c = is.get();
  if (  c == '\r' )
  {
    c = is.get();
    if ( c != '\n' )
    {
      is.putback(c);
    }
    c = '\n';
  }
  if (c == '\n')
    return is;
  
  while (c != EOF)
  {
    str.push_back(c);
    c = is.get();
    if (  c == '\r' )
    {
      c = is.get();
      if ( c != '\n' )
      {
        is.putback(c);
      }
      c = '\n';
      return is;
    }
    if (c == '\n')
    {
      return is;
    }
  }
  return is;
}

/* Can be optimised ?? */
/* Function is declared inline since it is a global function in a header file. It is not declared */
/* static in order not to get compiler warnings due to unused functions. */
//
// A note on efficiency: This is not the most efficient way to read a file.
// Indeed the many push_back calls can lead to many reallocation events for the string buffer.
// TODO: Could be made more efficient by measuring the file and by calling reserve.
inline void readFileIntoString(std::ifstream &is, faststring &str)
{
  int c;
  
  str.clear();
  
  c = is.get();
  while (true)
  {
    if (  c == '\r' )
    {
      str.push_back('\n');
      c = is.get();
      if ( c == '\n')
      {
        c = is.get();
      }
    }
    else if (c == '\n')
    {
      str.push_back('\n');
      c = is.get();
    }
    else
    {
      str.push_back(c);
      c = is.get();
    }
    if (c == EOF)
      return;
  }
}

//***********************************************************************
// Reads the content of a file and APPENDs it to he vector.
// NOTE: A vector<faststring> can be extemely inefficient.
//       When expanding the size of the vector, the vector class might
//       destruct and reconstruct all items, when reallocating them.
//***********************************************************************
inline void appendFileToVector(std::ifstream &is, std::vector<faststring> &v)
{
  faststring line;
  
  getline(is, line);
  while (is)
  {
    v.push_back(line);
    getline(is, line);
  }
}

inline void appendFileToList(std::ifstream &is, std::list<faststring> &l)
{
  faststring line;
  
  getline(is, line);
  while (is)
  {
    l.push_back(line);
    getline(is, line);
  }
}





//*************************************************************
// Tokenizer
//*************************************************************

// Note on efficiency:
// vector<faststring> can be inefficient as a container in the split functions.
// Expanding the vector leads not only to a relocation of the memory but also to
// the construction of copies and destruction of all existing elements.
// For many splitting events, a list should be favoured.


template <typename Container>
typename Container::size_type
split (Container &l, const faststring &s, char const * const ws)
{
  l.clear();
  const faststring::size_type  S = s.size();
  faststring::size_type  i = 0;
  
  while (i < S) {
    // eat leading whitespace
    while ((i < S) && (is_in_symbol_list__(s[i],ws)))  ++i;
    if (i == S)  return l.size();  // nothing left but WS
    
    // find end of word
    faststring::size_type  j = i+1;
    while ((j < S) && (!is_in_symbol_list__(s[j],ws)))  ++j;
    
    // add word
    l.push_back(s.substr(i,j-i));
    
    // set up for next loop
    i = j+1;
  }
  return l.size();
}


template <typename Container>
typename Container::size_type
split_at (Container &l, const faststring &s, const faststring &delim)
{
  faststring::size_type pos1=0;
  faststring::size_type pos2=0;
  
  while (pos2 != faststring::npos)
  {
    pos2 = s.find(delim, pos2); // Start of next delimiter
    
    if (pos2 >= s.size() )
      break;
    l.push_back(s.substr(pos1, pos2-pos1) );
    pos1 = pos2+delim.size(); // Start of next token
    pos2 = pos1;              // Start for next search
  }
  l.push_back(s.substr(pos1, pos2) );
  return l.size();
}


//
// Tokenizer which does not split braces.
//

inline void
skip_until_ws_respect(const faststring &s, faststring::size_type &pos, char const * const ws = "\r\n\t\v\f ")
{
  char c;
  
  unsigned count_parent = 0;
  unsigned count_brace  = 0;
  unsigned count_curly  = 0;
  unsigned count_sq     = 0;
  unsigned count_dq     = 0;
  
  faststring::size_type size = s.size();
  
  while (pos < size)
  {
    c = s[pos];
    if (c == '(')   { ++count_parent; }
    else if (c == ')')   { --count_parent; }
    else if (c == '[')   { ++count_brace;  }
    else if (c == ']')   { --count_brace;  }
    else if (c == '{')   { ++count_curly;  }
    else if (c == '}')   { --count_curly;  }
    else if (c == '\'')  { count_sq = (count_sq+1)%2;   }
    else if (c == '\"')  { count_dq = (count_dq+1)%2;   }
    
    if (is_in_symbol_list__(c, ws) && count_parent==0 && count_brace==0 && count_curly==0 && count_sq==0 && count_dq==0)
      return;
    
    ++pos;
  }
}

template <typename Container>
typename Container::size_type
split_respect (Container &l, const faststring &s, char const * const ws)
{
  l.clear();
  const faststring::size_type  S = s.size();
  faststring::size_type  i = 0;
  
  while (i < S) {
    // eat leading whitespace
    while ((i < S) && (is_in_symbol_list__(s[i],ws)))  ++i;
    if (i == S)  return l.size();  // nothing left but WS
    
    // find end of word
    faststring::size_type  j = i;  // We can't skip the first char which can be a brace.
    skip_until_ws_respect(s, j, ws);
    
    // add word
    l.push_back(s.substr(i,j-i));
    
    // set up for next loop
    i = j+1;
  }
  return l.size();
}

// Multiple successive delimiter result in multiple hits.
template <typename Container>
typename Container::size_type
split_strict (Container &l, const faststring &s, char const * const ws)
{
  l.clear();
  const faststring::size_type  S = s.size();
  faststring::size_type  i = 0;
  
  while (i < S) {
    // find end of word
    faststring::size_type  j = i;
    while ((j < S) && (!is_in_symbol_list__(s[j],ws)))  ++j;
    
    // add word
    l.push_back(s.substr(i,j-i));
    
    // set up for next loop
    i = j+1;
    
    if (i==S)  // Only true of last string is empty since otherwise i==S+1
    {
      l.push_back("");
    }
  }
  return l.size();
}

template <typename Container>
typename Container::size_type
split_strict_respect (Container &l, const faststring &s, char const * const ws)
{
  l.clear();
  const faststring::size_type  S = s.size();
        faststring::size_type  i = 0;
  
  while (i < S) {
    // find end of word
    faststring::size_type  j = i;  // We can't skip the first char which can be a brace.
    skip_until_ws_respect(s, j, ws);
    
    // add word
    l.push_back(s.substr(i,j-i));
    
    // set up for next loop
    i = j+1;
    
    if (i==S)  // Only true of last string is empty since otherwise i==S+1
    {
      l.push_back("");
    }
  }
  return l.size();
}



inline bool less_than_pointer_to_faststring(const faststring *a, const faststring *b)
{
  return *a < *b;
}

// string without digits has unsigned UINT_MAX as value.
// without digit if it does not happen to contain UINT_MAX is string.
inline bool less_than_first_unsigned_in_faststring(const faststring &a, const faststring &b)
{
  unsigned numa = a.extractFirstUnsigned();
  unsigned numb = b.extractFirstUnsigned();

  if (numa==numb)
    return a<b; // Revert to asciicode order.
  else
    return numa < numb;
}


struct less_than_pointer_to_faststring_struct
{
  bool operator()(const faststring* s1, const faststring* s2) const
  {
    return *s1 < *s2;
  }
};











#endif

/* String operations: */
/* I do not know what to do with this function: get_allocator	 Get allocator (public member function) */