amxmodx/dlls/sqlite/sdk/sh_string.h

368 lines
4.6 KiB
C
Raw Normal View History

2006-06-03 23:52:21 +04:00
/* ======== SourceMM ========
* Copyright (C) 2004-2005 Metamod:Source Development Team
* No warranties of any kind
2005-02-15 17:11:01 +03:00
*
2006-06-03 23:52:21 +04:00
* License: zlib/libpng
2005-02-15 17:11:01 +03:00
*
2006-06-03 23:52:21 +04:00
* Author(s): David "BAILOPAN" Anderson
* ============================
2005-02-15 17:11:01 +03:00
*/
2006-06-03 23:52:21 +04:00
/* AMX Mod X
*
* by the AMX Mod X Development Team
*/
2005-02-15 17:11:01 +03:00
#ifndef _INCLUDE_CSTRING_H
#define _INCLUDE_CSTRING_H
2005-09-11 01:04:05 +04:00
#include <string.h>
#include <stdio.h>
2006-06-03 23:52:21 +04:00
namespace SourceHook
{
2005-02-15 17:11:01 +03:00
class String
{
public:
String()
{
v = NULL;
2005-09-11 01:04:05 +04:00
a_size = 0;
//assign("");
2005-02-15 17:11:01 +03:00
}
~String()
{
if (v)
delete [] v;
}
String(const char *src)
{
v = NULL;
2005-09-11 01:04:05 +04:00
a_size = 0;
assign(src);
}
2005-11-15 23:48:11 +03:00
String(const String &src)
2005-02-15 17:11:01 +03:00
{
v = NULL;
2005-09-11 01:04:05 +04:00
a_size = 0;
2005-02-15 17:11:01 +03:00
assign(src.c_str());
}
const char *c_str() { return v?v:""; }
2005-09-11 01:04:05 +04:00
2005-02-15 17:11:01 +03:00
const char *c_str() const { return v?v:""; }
void append(const char *t)
{
2005-09-11 01:04:05 +04:00
Grow(size() + strlen(t) + 1);
2005-02-15 17:11:01 +03:00
strcat(v, t);
}
void append(const char c)
{
2005-09-11 01:04:05 +04:00
size_t len = size();
Grow(len + 2);
v[len] = c;
v[len + 1] = '\0';
2005-02-15 17:11:01 +03:00
}
void append(String &d)
{
2005-09-11 01:04:05 +04:00
append(d.c_str());
2005-02-15 17:11:01 +03:00
}
void assign(const String &src)
{
assign(src.c_str());
}
void assign(const char *d)
{
if (!d)
{
2005-09-11 01:04:05 +04:00
clear();
2005-02-15 17:11:01 +03:00
} else {
2006-06-03 23:52:21 +04:00
Grow(strlen(d) + 1, false);
strcpy(v, d);
2005-02-15 17:11:01 +03:00
}
}
void clear()
{
if (v)
2005-09-11 01:04:05 +04:00
v[0] = '\0';
2005-02-15 17:11:01 +03:00
}
2006-06-03 23:52:21 +04:00
int compare (const char *d)
2005-02-15 17:11:01 +03:00
{
2005-09-11 01:04:05 +04:00
if (!v)
return strcmp("", d);
else
return strcmp(v, d);
2005-02-15 17:11:01 +03:00
}
//Added this for amxx inclusion
bool empty()
{
2005-09-11 01:04:05 +04:00
if (!v)
return true;
if (v[0] == '\0')
2005-02-15 17:11:01 +03:00
return true;
return false;
}
2005-09-11 01:04:05 +04:00
size_t size()
2005-02-15 17:11:01 +03:00
{
2005-09-11 01:04:05 +04:00
if (v)
return strlen(v);
else
2005-02-15 17:11:01 +03:00
return 0;
}
int find(const char c, int index = 0)
{
2005-11-15 23:48:11 +03:00
int len = static_cast<int>(size());
2005-09-11 01:04:05 +04:00
if (len < 1)
2005-02-15 17:11:01 +03:00
return npos;
2005-11-15 23:48:11 +03:00
if (index >= len || index < 0)
2005-02-15 17:11:01 +03:00
return npos;
2005-11-15 23:48:11 +03:00
int i = 0;
for (i=index; i<len; i++)
2005-02-15 17:11:01 +03:00
{
if (v[i] == c)
{
return i;
}
}
return npos;
}
bool is_space(int c)
{
if (c == '\f' || c == '\n' ||
c == '\t' || c == '\r' ||
c == '\v' || c == ' ')
{
return true;
}
return false;
}
void trim()
{
if (!v)
return;
2005-09-11 01:04:05 +04:00
2005-02-15 17:11:01 +03:00
unsigned int i = 0;
unsigned int j = 0;
2005-09-11 01:04:05 +04:00
size_t len = strlen(v);
2005-02-15 17:11:01 +03:00
2005-09-11 01:04:05 +04:00
if (len == 1)
2005-02-15 17:11:01 +03:00
{
if (is_space(v[i]))
{
clear();
return;
}
}
unsigned char c0 = v[0];
if (is_space(c0))
{
2005-09-11 01:04:05 +04:00
for (i=0; i<len; i++)
2005-02-15 17:11:01 +03:00
{
2005-09-11 01:04:05 +04:00
if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==len-1)))
2005-02-15 17:11:01 +03:00
{
erase(0, i);
break;
}
}
}
2005-09-11 01:04:05 +04:00
len = strlen(v);
2005-02-15 17:11:01 +03:00
2005-09-11 01:04:05 +04:00
if (len < 1)
2005-02-15 17:11:01 +03:00
{
return;
}
2005-09-11 01:04:05 +04:00
if (is_space(v[len-1]))
2005-02-15 17:11:01 +03:00
{
for (i=len-1; i<len; i--)
2005-02-15 17:11:01 +03:00
{
if (!is_space(v[i])
|| (is_space(v[i]) && i==0))
{
erase(i+1, j);
break;
}
j++;
}
}
2005-09-11 01:04:05 +04:00
if (len == 1)
2005-02-15 17:11:01 +03:00
{
if (is_space(v[0]))
{
clear();
return;
}
}
}
2005-09-11 01:04:05 +04:00
void erase(unsigned int start, int num = npos)
2005-02-15 17:11:01 +03:00
{
if (!v)
2005-09-11 01:04:05 +04:00
return;
2005-02-15 17:11:01 +03:00
unsigned int i = 0;
2005-09-11 01:04:05 +04:00
size_t len = size();
2005-02-15 17:11:01 +03:00
//check for bounds
2005-11-15 23:48:11 +03:00
if (num == npos || start+num > len-start)
2005-09-11 01:04:05 +04:00
num = len - start;
2005-02-15 17:11:01 +03:00
//do the erasing
bool copyflag = false;
2005-09-11 01:04:05 +04:00
for (i=0; i<len; i++)
2005-02-15 17:11:01 +03:00
{
if (i>=start && i<start+num)
{
2005-09-11 01:04:05 +04:00
if (i+num < len)
2005-02-15 17:11:01 +03:00
{
v[i] = v[i+num];
} else {
v[i] = 0;
}
copyflag = true;
} else if (copyflag) {
2005-09-11 01:04:05 +04:00
if (i+num < len)
2005-02-15 17:11:01 +03:00
{
v[i] = v[i+num];
} else {
v[i] = 0;
}
}
}
2005-09-11 01:04:05 +04:00
len -= num;
v[len] = 0;
2005-02-15 17:11:01 +03:00
}
String substr(unsigned int index, int num = npos)
{
2005-09-11 01:04:05 +04:00
if (!v)
{
String b("");
return b;
}
2005-02-15 17:11:01 +03:00
String ns;
2005-09-11 01:04:05 +04:00
size_t len = size();
if (index >= len || !v)
2005-02-15 17:11:01 +03:00
return ns;
if (num == npos)
{
2005-09-11 01:04:05 +04:00
num = len - index;
} else if (index+num >= len) {
num = len - index;
2005-02-15 17:11:01 +03:00
}
2005-11-15 23:48:11 +03:00
unsigned int i = 0;
2005-09-11 01:04:05 +04:00
unsigned int nslen = num + 2;
2005-02-15 17:11:01 +03:00
2005-09-11 01:04:05 +04:00
ns.Grow(nslen);
2005-02-15 17:11:01 +03:00
2005-09-11 01:04:05 +04:00
for (i=index; i<index+num; i++)
ns.append(v[i]);
2005-02-15 17:11:01 +03:00
return ns;
}
void toLower()
{
if (!v)
return;
unsigned int i = 0;
2005-09-11 01:04:05 +04:00
size_t len = strlen(v);
for (i=0; i<len; i++)
2005-02-15 17:11:01 +03:00
{
if (v[i] >= 65 && v[i] <= 90)
2005-09-11 01:04:05 +04:00
v[i] &= ~(1<<5);
2005-02-15 17:11:01 +03:00
}
}
String & operator = (const String &src)
{
assign(src);
return *this;
}
String & operator = (const char *src)
{
assign(src);
return *this;
}
char operator [] (unsigned int index)
{
2005-09-11 01:04:05 +04:00
if (index > size() || !v)
2005-02-15 17:11:01 +03:00
{
return -1;
} else {
return v[index];
}
}
int at(int a)
{
2005-09-11 01:04:05 +04:00
if (a < 0 || a >= (int)size() || !v)
2005-02-15 17:11:01 +03:00
return -1;
return v[a];
}
bool at(int at, char c)
{
2005-09-11 01:04:05 +04:00
if (at < 0 || at >= (int)size() || !v)
2005-02-15 17:11:01 +03:00
return false;
v[at] = c;
return true;
}
private:
2005-09-11 01:04:05 +04:00
void Grow(unsigned int d, bool copy=true)
2005-02-15 17:11:01 +03:00
{
2005-09-11 01:04:05 +04:00
if (d <= a_size)
2005-02-15 17:11:01 +03:00
return;
2005-09-11 01:04:05 +04:00
char *n = new char[d + 1];
if (copy && v)
strcpy(n, v);
if (v)
delete [] v;
else
strcpy(n, "");
v = n;
a_size = d + 1;
2005-02-15 17:11:01 +03:00
}
char *v;
2005-09-11 01:04:05 +04:00
unsigned int a_size;
2005-02-15 17:11:01 +03:00
public:
static const int npos = -1;
};
2006-06-03 23:52:21 +04:00
}; //NAMESPACE
2005-02-15 17:11:01 +03:00
#endif //_INCLUDE_CSTRING_H