String.cpp

Go to the documentation of this file.

#include <String.h>
String::String()
{
  data = (char *) malloc(1);
  if(!data)
  {
    return;
  }
  data[0] = '\0';
  len = 0;
}

String::String(const char *src)
{
  data = strdup(src);
  if(data)
  {
    len = strlen(data);
  }
  else
  {
    len = 0;
  }
}

String::String(const char *src, unsigned int len)
{
  data = (char *) malloc(len + 1);
  if(!data)
  {
    this->len = 0;
    return;
  }
  memcpy(data, src, len);
  data[len] = '\0';
  this->len = len;
}

String::String(const String & str)
{
  len = str.len;
  data = (char *) malloc(len + 1);
  if(!data)
  {
    len = 0;
    return;
  }
  memcpy(data, str.data, len + 1);
}

String::~String()
{
  free(data);
}

String & String::operator+=(String & str)
{
  if (str.len)
  {
    data = (char *) realloc(data, len + str.len + 1);
    if(data)
    {
      memcpy(data + len, str.data, str.len + 1);
      len += str.len;
    }
  }
  return *this;
}

String & String::operator=(String s)
{
  if (&s == this)
    return *this;
  free(data);
  data = strdup(s.data);
  len = s.len;
  return *this;
}

String String::operator+(String & b)
{
  String c(*this);
  c += b;
  return c;
}

String & String::operator=(const char *str)
{
  free(data);
  len = strlen(str);
  data = strdup(str);
  return *this;
}

bool String::operator==(String & str)
{
  return (strcmp(data, str.data) == 0);
}

bool String::operator!=(String & str)
{
  return (strcmp(data, str.data) != 0);
}

bool String::operator>(String & str)
{
  return (strcmp(data, str.data) > 0);
}

bool String::operator<(String & str)
{
  return (strcmp(data, str.data) < 0);
}

char &String::operator[] (unsigned int index)
{
  return data[index];
}

void String::addSlashes()
{
  char *start = data;
  if (len)
  {
    char *buf = (char *) malloc(len << 1);
    if(!buf)
    {
      return;
    }
    unsigned int i = 0;
    while (*data)
    {
      if (*data == '\'' || *data == '\"' || *data == '\\')
      {
        buf[i++] = '\\';
      }
      buf[i++] = *data;
      data++;
    }
    buf[i] = '\0';
    len = i;
    buf = (char *) realloc(buf, i + 1);
    if(!buf)
    {
      len = 0;
      return;
    }
    free(start);
    data = buf;
  }
}

void String::replace(const char *search, const char *replace, unsigned int limit)
{
  int s_len = strlen(search);
  int r_len = strlen(replace);
  int pos = 0;
  int delta = r_len - s_len;
  unsigned int count = 0;
  while (pos < int (len) && (limit == 0 || (limit > 0 && count < limit)))
  {
    if (!strncmp(data + pos, search, s_len))
    {
      len += delta;
      char *buf = (char *) malloc(len + 1);
      if(!buf)
      {
        return;
      }
      if (pos)
        memcpy(buf, data, pos);
      memcpy(buf + pos, replace, r_len);
      memcpy(buf + pos + r_len, data + pos + s_len, len - delta - pos - s_len + 1);
      free(data);
      data = buf;
      pos += r_len;
    }
    else
    {
      pos++;
    }
  }
}

int String::fastReplace(const char *search, const char *replace, unsigned int limit)
{
  register int start, slen, delta, dlen, rlen;
  int idx = 0;
  unsigned int count = 0;
  char *buf;
  slen = strlen(search);
  rlen = strlen(replace);
  delta = rlen - slen;
  dlen = len;
  while ((start = fastStrPos(data + idx, search)) >= 0 && !(limit > 0 && limit <= count))
  {
    buf = (char *) malloc(dlen + delta + 1);
    if(!buf)
    {
      return count;
    }
    start += idx;
    if (start)
      memcpy(buf, data, start);
    memcpy(buf + start, replace, rlen);
    memcpy(buf + start + rlen, data + start + slen, dlen - (start + slen));
    dlen += delta;
    free(data);
    buf[dlen] = 0;
    data = buf;
    idx = start + rlen;
    count++;
  }
  len = dlen;
  return count;
}

int String::strPos(const char *search, unsigned int offset)
{
  char *start = strstr(data + offset, search);
  if (start)
  {
    return int (start - data);
  }
  return -1;
}

int String::fastStrPos(const char *search, unsigned int offset)
{
  int plen;
  int d[256];
  register int c;
  register int pindx;
  register int cmppos;
  register int endpos;
  char *data_res = data + offset;
  plen = strlen(search);
  for (c = 0; c < 256; c++)
  {
    d[c] = len;
  }
  for (c = 0; c < plen - 1; c++)
  {
    d[search[c] & 0377] = plen - 1 - c;
  }
  for (endpos = plen - 1; endpos < int (len);)
  {
    for (cmppos = endpos, pindx = (plen - 1); pindx >= 0; cmppos--, pindx--)
    {
      if (data_res[cmppos] != search[pindx])
      {
        endpos += d[data_res[endpos] & 0377];
        break;
      }
    }
    if (pindx < 0)
    {
      return endpos - (plen - 1) + offset;
    }
  }
  return -1;
}

int String::fastStrPos(const unsigned char *haystack, int hlen, const unsigned char *needle, int nlen, unsigned int offset)
{
  size_t scan = 0;
  size_t bad_char_skip[UCHAR_MAX + 1]; 
  if (nlen <= 0 || !haystack || !needle)
        return -1;
  haystack += offset;
  const unsigned char *start = haystack;
  hlen -= offset;
  for (scan = 0; scan <= UCHAR_MAX; scan = scan + 1)
  {
      bad_char_skip[scan] = nlen;
  }
  size_t last = nlen - 1;
  for (scan = 0; scan < last; scan = scan + 1)
  {
      bad_char_skip[(unsigned int)(needle[scan])] = last - scan;
  }
  while (hlen >= nlen)
  {
      for (scan = last; haystack[scan] == needle[scan]; scan = scan - 1)
          if (scan == 0) 
              return int(haystack - start) + offset;
      hlen     -= bad_char_skip[(unsigned int)(haystack[last])];
      haystack += bad_char_skip[(unsigned int)(haystack[last])];
  }
  return -1;
}
int String::fastStrPos(const char *data_tmp, const char *search)
{
  int len = strlen(data_tmp);
  int plen;
  int d[256];
  register int c;
  register int pindx;
  register int cmppos;
  register int endpos;
  plen = strlen(search);
  for (c = 0; c < 256; c++)
  {
    d[c] = len;
  }
  for (c = 0; c < plen - 1; c++)
  {
    d[search[c] & 0377] = plen - 1 - c;
  }
  for (endpos = plen - 1; endpos < len;)
  {
    for (cmppos = endpos, pindx = (plen - 1); pindx >= 0; cmppos--, pindx--)
    {
      if (data_tmp[cmppos] != search[pindx])
      {
        endpos += d[data_tmp[endpos] & 0377];
        break;
      }
    }
    if (pindx < 0)
    {
      return endpos - (plen - 1);
    }
  }
  return -1;
}

void String::urlEncode()
{
  char symbols[]="0123456789ABCDEF";
  char *encoded = NULL;
  register int enc_len = 0;
  encoded = (char *) malloc(len * 3 + 1);
  if(!encoded)
  {
    return;
  }
  for (unsigned int i = 0; i < len; i++)
  {
    if (data[i] < 45 || (data[i] == 47) || (data[i] > 57 && data[i] < 65)
        || (data[i] > 90 && data[i] < 95) || (data[i] == 96)
        || (data[i] > 122))
    {
      encoded[enc_len++] = '%';
      encoded[enc_len++] = symbols[(((u_int8_t)data[i]) >> 4) & 0xF];
      encoded[enc_len++] = symbols[u_int8_t(data[i]) & 0xF];
    }
    else
    {
      encoded[enc_len] = data[i];
      enc_len++;
    }
  }
  encoded = (char *) realloc(encoded, enc_len + 1);
  if(encoded)
  {
    encoded[enc_len] = 0;
    free(data);
    data = encoded;
    len = enc_len;
  }
}

void String::urlDecode()
{
#define FROM_HEX( x ) ((((x)>=0x30) && ((x)<=0x39))? ((x) - 0x30) : ((x) - 'A' + 0xA))
  char *decoded = (char *) malloc(len + 1);
  if(!decoded)
  {
    return;
  }
  char *cur = decoded;
  char *url = data;
  while (*url)
  {
    if (*url == '%')
    {
      *(cur++) = (FROM_HEX(toupper(url[1])) << 4) + (FROM_HEX(toupper(url[2])));
      url += 3;
    }
    else
    {
      *(cur++) = *url == '+' ? ' ' : *url;
      url++;
    }
  }
  *cur = '\0';
  free(data);
  len = (unsigned int) (cur - decoded);
  data = decoded;
}

unsigned int String::length()
{
  return len;
}

String & String::subStr(unsigned int pos, unsigned int len)
{
  String *buf = new(std::nothrow) String();
  if(!buf)
  {
    return *this;
  }
  if (pos >= this->len)
  {
    return *buf;
  }
  if (len + pos > this->len)
  {
    len = this->len - pos;
  }
  if (len)
  {
    buf->len = len;
    free(buf->data); // fix!!!
    buf->data = (char *) malloc(len + 1);
    if(!buf->data)
    {
      buf->len = 0;
      return *buf;
    }
    memcpy(buf->data, data+pos, len);
    buf->data[len] = '\0';
  }
  return *buf;
}

const char *String::c_str()
{
  return data;
}

String **String::split(const char *pattern)
{
  unsigned int plen = strlen(pattern);
  List < String * >res;
  unsigned int start = 0;
  if (plen > len)
    return NULL;
  for (unsigned int i = 0; i < len - plen;)
  {
    while (strncmp(data + i, pattern, plen) == 0 && i < len)
    {
      i += plen;
    }
    start = i;
    while (strncmp(data + i, pattern, plen) && i < len)
    {
      i++;
    }
    if (i > start && i <= len)
    {
      res.pushDown(new(std::nothrow) String(data + start, i - start));
    }
  }
  String **result = new(std::nothrow) String *[res.getCount() + 1];
  if(result)
  {
    result[res.getCount()] = NULL;
    for (unsigned int i = 0; i < res.getCount(); i++)
    {
      result[i] = res[i];
    }
  }
  return result;
}

void String::fromInt(int x)
{
  char buf[15];
  unsigned int count = 0;
  if (data)
  {
    free(data);
    data = (char *) malloc(15);
    if(!data)
    {
      len = 0;
      return;
    }
  }
  len = 0;
  char *numeric = data;
  if (x < 0)
  {
    *numeric = '-';
    numeric++;
    x *= -1;
    len = 1;
  }
  do
  {
    buf[count++] = (char) ((x % 10) + 0x30);
    x /= 10;
  }
  while (x);
  len += count;
  while (count)
  {
    *numeric = buf[--count];
    numeric++;
  }
  *numeric = '\0';
}

void String::fromInt64(long long x)
{
  char buf[21];
  unsigned int count = 0;
  if (data)
  {
    free(data);
    data = (char *) malloc(21);
    if(!data)
    {
      len = 0;
      return;
    }
  }
  len = 0;
  char *numeric = data;
  if (x < 0)
  {
    *numeric = '-';
    numeric++;
    x *= -1;
    len = 1;
  }
  do
  {
    buf[count++] = (char) ((x % 10) + 0x30);
    x /= 10;
  }
  while (x);
  len += count;
  while (count)
  {
    *numeric = buf[--count];
    numeric++;
  }
  *numeric = '\0';
}

void String::fromUInt(unsigned int x)
{
  char buf[15];
  unsigned int count = 0;
  if (data)
  {
    free(data);
    data = (char *) malloc(15);
    if(!data)
    {
      len = 0;
      return;
    }
  }
  len = 0;
  char *numeric = data;
  do
  {
    buf[count++] = (char) ((x % 10) + 0x30);
    x /= 10;
  }
  while (x);
  len += count;
  while (count)
  {
    *numeric = buf[--count];
    numeric++;
  }
  *numeric = '\0';
}

void String::fromUInt64(unsigned long long x)
{
  char buf[21];
  unsigned int count = 0;
  if (data)
  {
    free(data);
    data = (char *) malloc(21);
    if(!data)
    {
      len = 0;
      return;
    }
  }
  len = 0;
  char *numeric = data;
  do
  {
    buf[count++] = (char) ((x % 10) + 0x30);
    x /= 10;
  }
  while (x);
  len += count;
  while (count)
  {
    *numeric = buf[--count];
    numeric++;
  }
  *numeric = '\0';
}


std::ostream & operator<<(std::ostream & out, String & str)
{
  out << str.data;
  return out;
}

void String::implode(unsigned int count, const char *glue, ...)
{
  va_list ap;
  va_start(ap, glue);
  char *str = NULL;
  unsigned int slen = 0;
  unsigned int glen = 0;
  if (glue)
  {
    glen = strlen(glue);
  }
  if (len)
  {
    free(data);
    len = 0;
    data = (char *) malloc(1);
    if(!data)
    {
      return;
    }
  }
  while (count--)
  {
    str = va_arg(ap, char *);
    slen = strlen(str);
    if (count && glen)
    {
      data = (char *) realloc(data, len + slen + glen + 1);
      if(!data)
      {
        len = 0;
        return;
      }
      memcpy(data + len, str, slen);
      memcpy(data + len + slen, glue, glen);
      len += glen + slen;
    }
    else
    {
      data = (char *) realloc(data, len + slen + 1);
      if(!data)
      {
        len = 0;
        return;
      }
      memcpy(data + len, str, slen);
      len += slen;
    }
  }
  data[len] = '\0';
  va_end(ap);
}

void String::implode(const char *glue, char **str)
{
  unsigned int slen = 0;
  unsigned int glen = 0;
  if (glue)
  {
    glen = strlen(glue);
  }
  if (len)
  {
    free(data);
    len = 0;
    data = (char *) malloc(1);
    if(!data)
    {
      return;
    }
  }
  while (str)
  {
    slen = strlen(*str);
    if (str[1] && glen)
    {
      data = (char *) realloc(data, len + slen + glen + 1);
      if(!data)
      {
        len = 0;
        return;
      }
      memcpy(data + len, *str, slen);
      memcpy(data + len + slen, glue, glen);
      len += glen + slen;
    }
    else
    {
      data = (char *) realloc(data, len + slen + 1);
      if(data)
      {
        len = 0;
        return;
      }
      memcpy(data + len, *str, slen);
      len += slen;
    }
    str++;
  }
  data[len] = '\0';
}
bool String::wildcmp(char *wild) 
{
  char *string = data;
  char *cp, *mp;
  while( (*string) && (*wild != '*')) 
  {
    if( (*wild != *string) && (*wild != '?') ) 
    {
      return false;
    }
    wild++;
    string++;
  }
  while(*string) 
  {
    if(*wild == '*')
    {
      if(!*++wild)
      {
        return true;
      }
      mp = wild;
      cp = string+1;
    } 
    else 
      if( (*wild == *string) || (*wild == '?') )
      {
        wild++;
        string++;
      } 
      else 
      {
        wild = mp;
        string = cp++;
      }
  }
  while( *wild == '*' ) 
  {
     wild++;
  }
  return *wild == '\0';
}

bool String::wildcmp(String &pattern) 
{
  return this->wildcmp(pattern.data);
}

unsigned int String::jsonEncode(const char *input, unsigned int len, char **result)
{
  static char hexmap[] = "0123456789abcdef";
  unsigned int outLen = 0;
  u_int8_t *src = (u_int8_t*)input;
  for(unsigned int i = 0; i < len; )
  {
    if(src[i] < 128)
    {
      switch(src[i])
      {
        case '"':
        case '\\':
        case '/':
        case '\b':
        case '\f':
        case '\n':
        case '\r':
        case '\t':outLen += 2;break;
        default: outLen++;
      }
      i++;
    }
    else
    {
      if((src[i] & 0xF0) == 0xF0) i += 4;
      else if((src[i] & 0xE0) == 0xE0) i += 3;
           else i += 2;
      outLen += 6;
    }
  }
  if(outLen)
  {
    char *dst = (char*)malloc(outLen + 1);
    for(unsigned int i = 0, j = 0; i < len; )
    {
      if(src[i] < 128)
      {
        switch(src[i])
        {
          case '"':
            dst[j++] = '\\';
            dst[j++] = '"';
            break;
          case '\\':
            dst[j++] = '\\';
            dst[j++] = '\\';
            break;
          case '/':
            dst[j++] = '\\';
            dst[j++] = '/';
            break;
          case '\b':
            dst[j++] = '\\';
            dst[j++] = 'b';
            break;
          case '\f':
            dst[j++] = '\\';
            dst[j++] = 'f';
            break;
          case '\n':
            dst[j++] = '\\';
            dst[j++] = 'n';
            break;
          case '\r':
            dst[j++] = '\\';
            dst[j++] = 'r';
            break;
          case '\t':
            dst[j++] = '\\';
            dst[j++] = 't';
            break;
          default: dst[j++] = src[i];
        }
        i++;
      }
      else
      {
        if((src[i] & 0xF0) == 0xF0)
        {//11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
          i += 4; 
        }
        else
        {
          u_int16_t symb = 0;
          dst[j++] = '\\';
          dst[j++] = 'u';
          if((src[i] & 0xE0) == 0xE0)
          {//1110xxxx 10xxxxxx 10xxxxxx
            symb = ((src[i] & 0xF) << 12) | ((src[i + 1] & 0x3F) << 6) | (src[i + 2] & 0x3F);
            i += 3;
          }
          else
          {//110xxxxx 10xxxxxx
            symb = ((src[i] & 0x1F) << 6) | (src[i + 1] & 0x3F);
            i += 2;
          }
          dst[j++] = hexmap[(symb >> 12) & 0xf];
          dst[j++] = hexmap[(symb >> 8) & 0xf];
          dst[j++] = hexmap[(symb >> 4) & 0xf];
          dst[j++] = hexmap[symb & 0xf];
        }
      }
    }
    dst[outLen] = '\0';
    *result = dst;
  }
  return outLen;
}
void String::jsonEncode()
{
  if(len)
  {
    char *ret;
    len = jsonEncode(data, len, &ret);
    free(data);
    data = ret;
  }
}