sourcehook/sh_string.h
author David Anderson <dvander@alliedmods.net>
Tue Sep 13 16:52:14 2005 +0000 (2005-09-13)
changeset 102 894e7be6c431
parent 99 bfbb04d6683f
child 103 3e818125b830
permissions -rwxr-xr-x
Imported growable TinyHash class to replace std::map
     1 /* ======== SourceMM ========
     2 * Copyright (C) 2004-2005 Metamod:Source Development Team
     3 * No warranties of any kind
     4 *
     5 * License: zlib/libpng
     6 *
     7 * Author(s): David "BAILOPAN" Anderson
     8 * ============================
     9 */
    10 
    11 /* AMX Mod X
    12  *
    13  * by the AMX Mod X Development Team
    14  */
    15 
    16 #ifndef _INCLUDE_CSTRING_H
    17 #define _INCLUDE_CSTRING_H
    18 
    19 #include <string.h>
    20 #include <stdio.h>
    21 
    22 namespace SourceHook
    23 {
    24 
    25 class String
    26 {
    27 public:
    28 	String() 
    29 	{
    30 		v = NULL;
    31 		a_size = 0;
    32 		//assign("");
    33 	}
    34 
    35 	~String()
    36 	{ 
    37 		if (v) 
    38 			delete [] v; 
    39 	}
    40 
    41 	String(const char *src) 
    42 	{
    43 		v = NULL; 
    44 		a_size = 0;
    45 		assign(src); 
    46 	}
    47 
    48 	String(String &src) 
    49 	{
    50 		v = NULL;
    51 		a_size = 0;
    52 		assign(src.c_str()); 
    53 	}
    54 
    55 	const char *c_str() { return v?v:""; }
    56 
    57 	const char *c_str() const { return v?v:""; }
    58 
    59 	void append(const char *t)
    60 	{
    61 		Grow(size() + strlen(t) + 1);
    62 		strcat(v, t);
    63 	}
    64 
    65 	void append(const char c)
    66 	{
    67 		size_t len = size();
    68 		Grow(len + 2);
    69 		v[len] = c;
    70 		v[len + 1] = '\0';
    71 	}
    72 
    73 	void append(String &d)
    74 	{
    75 		append(d.c_str());
    76 	}
    77 
    78 	void assign(const String &src)
    79 	{
    80 		assign(src.c_str());
    81 	}
    82 
    83 	void assign(const char *d)
    84 	{
    85 		if (!d)
    86 		{
    87 			clear();
    88 		} else {
    89 			Grow(strlen(d) + 1, false);
    90 			strcpy(v, d);
    91 		}
    92 	}
    93 
    94 	void clear()
    95 	{
    96 		if (v)
    97 			v[0] = '\0';
    98 	}
    99 
   100 	int compare (const char *d)
   101 	{
   102 		if (!v)
   103 			return strcmp("", d);
   104 		else
   105 			return strcmp(v, d);
   106 	}
   107 
   108 	//Added this for amxx inclusion
   109 	bool empty()
   110 	{
   111 		if (!v)
   112 			return true;
   113 
   114 		if (v[0] == '\0')
   115 			return true;
   116 
   117 		return false;
   118 	}
   119 
   120 	size_t size()
   121 	{
   122 		if (v)
   123 			return strlen(v);
   124 		else
   125 			return 0;
   126 	}
   127 
   128 	int find(const char c, int index = 0)
   129 	{
   130 		size_t len = size();
   131 		if (len < 1)
   132 			return npos;
   133 		if (index >= (int)len || index < 0)
   134 			return npos;
   135 		unsigned int i = 0;
   136 		for (i=index; i<(int)len; i++)
   137 		{
   138 			if (v[i] == c)
   139 			{
   140 				return i;
   141 			}
   142 		}
   143 
   144 		return npos;
   145 	}
   146 
   147 	bool is_space(int c)
   148 	{
   149 		if (c == '\f' || c == '\n' ||
   150 			c == '\t' || c == '\r' ||
   151 			c == '\v' || c == ' ')
   152 		{
   153 			return true;
   154 		}
   155 
   156 		return false;
   157 	}
   158 	
   159 	void trim()
   160 	{
   161 		if (!v)
   162 			return;
   163 
   164 		unsigned int i = 0;
   165 		unsigned int j = 0;
   166 		size_t len = strlen(v);
   167 
   168 		if (len == 1)
   169 		{
   170 			if (is_space(v[i]))
   171 			{
   172 				clear();
   173 				return;
   174 			} 
   175 		}
   176 
   177 		unsigned char c0 = v[0];
   178 
   179 		if (is_space(c0))
   180 		{
   181 			for (i=0; i<len; i++)
   182 			{
   183 				if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==len-1)))
   184 				{
   185 					erase(0, i);
   186 					break;
   187 				}
   188 			}
   189 		}
   190 
   191 		len = strlen(v);
   192 
   193 		if (len < 1)
   194 		{
   195 			return;
   196 		}
   197 
   198 		if (is_space(v[len-1]))
   199 		{
   200 			for (i=len-1; i>=0; i--)
   201 			{
   202 				if (!is_space(v[i])
   203 					|| (is_space(v[i]) && i==0))
   204 				{
   205 					erase(i+1, j);
   206 					break;
   207 				}
   208 				j++;
   209 			}
   210 		}
   211 
   212 		if (len == 1)
   213 		{
   214 			if (is_space(v[0]))
   215 			{
   216 				clear();
   217 				return;
   218 			}
   219 		}
   220 	}
   221 
   222 	void erase(unsigned int start, int num = npos)
   223 	{
   224 		if (!v)
   225 			return;
   226 		unsigned int i = 0;
   227 		size_t len = size();
   228 		//check for bounds
   229 		if (num == npos || start+num > len-num+1)
   230 			num = len - start;
   231 		//do the erasing
   232 		bool copyflag = false;
   233 		for (i=0; i<len; i++)
   234 		{
   235 			if (i>=start && i<start+num)
   236 			{
   237 				if (i+num < len)
   238 				{	
   239 					v[i] = v[i+num];
   240 				} else {
   241 					v[i] = 0;
   242 				}
   243 				copyflag = true;
   244 			} else if (copyflag) {
   245 				if (i+num < len)
   246 				{
   247 					v[i] = v[i+num];
   248 				} else {
   249 					v[i] = 0;
   250 				}
   251 			}
   252 		}
   253 		len -= num;
   254 		v[len] = 0;
   255 	}
   256 
   257 	String substr(unsigned int index, int num = npos)
   258 	{
   259 		if (!v)
   260 		{
   261 			String b("");
   262 			return b;
   263 		}
   264 
   265 		String ns;
   266 
   267 		size_t len = size();
   268 
   269 		if (index >= len || !v)
   270 			return ns;
   271 		
   272 		if (num == npos)
   273 		{
   274 			num = len - index;
   275 		} else if (index+num >= len) {
   276 			num = len - index;
   277 		}
   278 
   279 		unsigned int i = 0, j=0;
   280 		unsigned int nslen = num + 2;
   281 
   282 		ns.Grow(nslen);
   283 
   284 		for (i=index; i<index+num; i++)
   285 			ns.append(v[i]);
   286 
   287 		return ns;
   288 	}
   289 
   290 	void toLower()
   291 	{
   292 		if (!v)
   293 			return;
   294 		unsigned int i = 0;
   295 		size_t len = strlen(v);
   296 		for (i=0; i<len; i++)
   297 		{
   298 			if (v[i] >= 65 && v[i] <= 90)
   299 				v[i] &= ~(1<<5);
   300 		}
   301 	}
   302 
   303 	String & operator = (const String &src)
   304 	{
   305 		assign(src);
   306 		return *this;
   307 	}
   308 
   309 	String & operator = (const char *src)
   310 	{
   311 		assign(src);
   312 		return *this;
   313 
   314 	}
   315 
   316 	char operator [] (unsigned int index)
   317 	{
   318 		if (index > size() || !v)
   319 		{
   320 			return -1;
   321 		} else {
   322 			return v[index];
   323 		}
   324 	}
   325 
   326 	int at(int a)
   327 	{
   328 		if (a < 0 || a >= (int)size() || !v)
   329 			return -1;
   330 
   331 		return v[a];
   332 	}
   333 
   334 	bool at(int at, char c)
   335 	{
   336 		if (at < 0 || at >= (int)size() || !v)
   337 			return false;
   338 
   339 		v[at] = c;
   340 
   341 		return true;
   342 	}
   343 
   344 private:
   345 	void Grow(unsigned int d, bool copy=true)
   346 	{
   347 		if (d <= a_size)
   348 			return;
   349 		char *n = new char[d + 1];
   350 		if (copy && v)
   351 			strcpy(n, v);
   352 		if (v)
   353 			delete [] v;
   354 		else
   355 			strcpy(n, "");			
   356 		v = n;
   357 		a_size = d + 1;
   358 	}
   359 
   360 	char *v;
   361 	unsigned int a_size;
   362 public:
   363 	static const int npos = -1;
   364 };
   365 
   366 };	//NAMESPACE
   367 
   368 #endif //_INCLUDE_CSTRING_H