kolibrios-fun/contrib/media/updf/include/string

#ifndef _STRING_INCLUDED
#define _STRING_INCLUDED
#include <stdlib.h>
#include <string.h>
namespace std
{
  class string
  {
    char* data;
  public:
    string() {data=(char*)malloc(1);data[0]=0;}
    string(const char* a)
    {
      int len=strlen(a)+1;
      data=(char*)malloc(len);
      memcpy(data,a,len);
    }
    string(char c)
    {
      data=(char*)malloc(2);
      data[0]=c;data[1]=0;
    }
    string(const string& s)
    {
      unsigned sz = s.size()+1;
      data=(char*)malloc(sz);
      memcpy(data,s.c_str(),sz);
    }
    ~string() {free(data);}
    string& operator=(const char* s)
    {free(data);unsigned len=strlen(s)+1;data=(char*)malloc(len);
    memcpy(data,s,len);return *this;}
    string& operator=(const string& s)
    {free(data);unsigned len=s.size()+1;data=(char*)malloc(len);
    memcpy(data,s.c_str(),len);return *this;}
    const char* c_str() const {return data;}
    char& operator[](unsigned pos) {return data[pos];}
    char operator[](unsigned pos) const {return data[pos];}
    unsigned size() const {return strlen(data);}
    unsigned length() const {return size();}
    bool operator==(const char* str2) const {return !strcmp(data,str2);}
    bool operator==(const string& str2) const {return !strcmp(data,str2.data);}
    int compare(const char* str2) {return strcmp(data,str2);}
    bool operator!=(const char* str2) const {return (bool)strcmp(data,str2);}
    string& replace(unsigned p0,unsigned n0,const string& str)
    {
      unsigned sz = str.size();
      char* newdata=(char*)malloc(size()+1+sz-n0);
      memcpy(newdata,data,p0);
      memcpy(newdata+p0,str.c_str(),sz);
      memcpy(newdata+p0+sz,data+p0+n0,size()+1-p0-n0);
      free(data);
      data=newdata;
      return *this;
    }
    string& insert(size_t posl,const string& str)
    { return replace(posl,0,str); }
    string& operator+=(char c)
    {
      unsigned sz=size();
      data=(char*)realloc(data,sz+2);
      data[sz]=c;data[sz+1]=0;
      return *this;
    }
    string& operator+=(const string& s)
    {
      unsigned mysz=size();
      unsigned ssz=s.size();
      data=(char*)realloc(data,mysz+1+ssz);
      memcpy(data+mysz,s.c_str(),ssz+1);
      return *this;
    }
//    friend string operator+(const string& s1, const char* s2);
//    friend string operator+(const char* s1, const string& s2);
    string& assign(const string& str, unsigned pos, unsigned n)
    {
      unsigned len=strlen(str.data);
      if (pos>len)
        pos=len;
      if (n>len||pos+n>len)
        n=len-pos;
      char* d=(char*)malloc(n+1);
      memcpy(d,str.c_str()+pos,n);
      d[n]=0;
      free(data);
      data=d;
      return *this;
    }
    string& assign(const char* s)
    {
      free(data);
      unsigned sz=strlen(s)+1;
      data=(char*)malloc(sz);
      memcpy(data,s,sz);
      return *this;
    }
    string& assign(const string& str)
    { return assign(str.data); }
    size_t find_first_of(const char* str, size_t pos=0) const
    {
      const char* p = data;
      while (pos)
      {
        if (!*p)
          return npos;
        p++;
        pos--;
      }
      while (*p)
      {
        if (strchr(str,*p))
          return p-data;
        p++;
      }
      return npos;
    }
    size_t find_first_of(const string& str, size_t pos=0) const
    { return find_first_of(str.data, pos); }
    size_t find_first_not_of(const char* str, size_t pos=0) const
    {
      const char* p = data;
      while (pos)
      {
        if (!*p)
          return npos;
        p++;
        pos--;
      }
      while (*p)
      {
        if (!strchr(str,*p))
          return p-data;
        p++;
      }
      return npos;
    }
    size_t find_first_not_of(const string& str, size_t pos=0) const
    { return find_first_not_of(str.data, pos); }
    size_t find_last_not_of(const char* str, size_t pos=npos) const
    {
      const char* p = data;
      while (pos)
      {
        if (!*p)
        {
          p--;
          break;
        }
        p++;
        pos--;
      }
      for (;;)
      {
        if (p<data)
          return npos;
        if (!strchr(str,*p))
          return p-data;
        p--;
      }
    }
    size_t find_last_not_of(const string& str, size_t pos=npos) const
    { return find_last_not_of(str.data, pos); }
    class iterator
    {
      char* cur;
    public:
      iterator(char* c):cur(c) {}
      iterator(const iterator& i):cur(i.cur) {}
      iterator& operator++() {++cur;return *this;}
      iterator operator++(int) {iterator tmp(*this);++cur;return tmp;}
      bool operator==(iterator it) {return cur==it.cur;}
      bool operator!=(iterator it) {return cur!=it.cur;}
      char& operator*() {return *cur;}
    };
    iterator begin() {return iterator(data);}
    iterator end() {return iterator(data+strlen(data));}
//    void erase() {free(data);data=(char*)malloc(1);data[0]=0;}
    string& erase(unsigned p0=0, unsigned n=(unsigned)-1)
    {
      unsigned sz=size();
      if (n>sz-p0) n=sz-p0;
      char* d=(char*)malloc(sz+1-n);
      memcpy(d,data,p0);
      memcpy(d+p0,data+p0+n,sz+1-n-p0);
      free(data);
      data=d;
      return *this;
    }
    typedef unsigned size_type;
    static const size_type npos=(size_type)-1;
    size_type find(const char* s, size_type pos=0) const
    {
      char* p=strstr(data+pos,s);
      if (!p) return npos;
      return p-data;
    }
    size_type find(char c, size_type pos=0) const
    {
      char* p=strchr(data+pos,c);
      if (!p) return npos;
      return p-data;
    }
    size_type rfind(char c, size_type pos=npos) const
    {
      size_type len=strlen(data);
      if (pos>len)
        pos=len;
      while (pos--)
        if (data[pos]==c)
          return pos;
      return npos;
    }
    string substr(unsigned pos=0,unsigned n=npos)
    {
      string res(data+pos);
      if (n<res.size()) res.erase(n);
      return res;
    }
    void clear(void)
    {
      data[0]=0;
    }
    bool empty(void) const
    {
      return (data[0]==0);
    }
    void _toupper(void)
    { strupr(data); }
    void _tolower(void)
    { strlwr(data); }
  };
}

inline std::string operator+(const std::string& s1, const char* s2)
{
  std::string res(s1);
  res += s2;
  return res;
}
inline std::string operator+(const char* s1, const std::string& s2)
{
  std::string res(s1);
  res += s2;
  return res;
}
inline std::string operator+(const std::string& s1, const std::string& s2)
{
  std::string res(s1);
  res += s2;
  return res;
}

#endif