sourcehook/sh_vector.h
author Pavol Marko <pavolmarko@gmail.com>
Sun May 14 19:07:01 2006 +0000 (2006-05-14)
changeset 200 e1426a1a3fcd
parent 154 083cb82d97df
child 204 e6cfa97ef258
permissions -rwxr-xr-x
Fixed linux/gcc/amd64
     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): Pavol "PM OnoTo" Marko
     8 * ============================
     9 */
    10 
    11 #ifndef __CVECTOR_H__
    12 #define __CVECTOR_H__
    13 
    14 #include <assert.h>
    15 
    16 //This file originally from AMX Mod X
    17 namespace SourceHook
    18 {
    19 // Vector
    20 template <class T> class CVector
    21 {
    22 	bool Grow()
    23 	{
    24 		// automatic grow
    25 		size_t newSize = m_Size * 2;
    26 		if (newSize == 0)
    27 			newSize = 8;					// a good init value
    28 		T *newData = new T[newSize];
    29 		if (!newData)
    30 			return false;
    31 		if (m_Data)
    32 		{
    33 			for (size_t i=0; i<m_CurrentUsedSize; i++)
    34 				newData[i] = m_Data[i];
    35 			delete [] m_Data;
    36 		}
    37 		m_Data = newData;
    38 		m_Size = newSize;
    39 		return true;
    40 	}
    41 
    42 	bool GrowIfNeeded()
    43 	{
    44 		if (m_CurrentUsedSize >= m_Size)
    45 			return Grow();
    46 		else
    47 			return true;
    48 	}
    49 
    50 	bool ChangeSize(size_t size)
    51 	{
    52 		// change size
    53 		if (size == m_Size)
    54 			return true;
    55 
    56 		if (!size)
    57 		{
    58 			if (m_Data)
    59 			{
    60 				delete [] m_Data;
    61 				m_Data = NULL;
    62 				m_Size = 0;
    63 			}
    64 			return true;
    65 		}
    66 
    67 		T *newData = new T[size];
    68 		if (!newData)
    69 			return false;
    70 		if (m_Data)
    71 		{
    72 			size_t end = (m_CurrentUsedSize < size) ? (m_CurrentUsedSize) : size;
    73 			for (size_t i=0; i<end; i++)
    74 				newData[i] = m_Data[i];
    75 			delete [] m_Data;
    76 		}
    77 		m_Data = newData;
    78 		m_Size = size;
    79 		if (m_CurrentUsedSize > m_Size)
    80 			m_CurrentUsedSize = m_Size;
    81 
    82 		return true;
    83 	}
    84 
    85 	void FreeMemIfPossible()
    86 	{
    87 		if (!m_Data)
    88 			return;
    89 
    90 		if (!m_CurrentUsedSize)
    91 		{
    92 			ChangeSize(0);
    93 			return;
    94 		}
    95 
    96 		size_t newSize = m_Size;
    97 		while (m_CurrentUsedSize <= newSize / 2)
    98 			newSize /= 2;
    99 
   100 		if (newSize != m_Size)
   101 			ChangeSize(newSize);
   102 	}
   103 protected:
   104 	T *m_Data;
   105 	size_t m_Size;
   106 	size_t m_CurrentUsedSize;
   107 public:
   108 	class iterator
   109 	{
   110 	protected:
   111 		T *m_Ptr;
   112 	public:
   113 		// constructors / destructors
   114 		iterator()
   115 		{
   116 			m_Ptr = NULL;
   117 		}
   118 
   119 		iterator(T * ptr)
   120 		{
   121 			m_Ptr = ptr;
   122 		}
   123 
   124 		// member functions
   125 		T * base()
   126 		{
   127 			return m_Ptr;
   128 		}
   129 
   130 		const T * base() const
   131 		{
   132 			return m_Ptr;
   133 		}
   134 
   135 		// operators
   136 		T & operator*()
   137 		{
   138 			return *m_Ptr;
   139 		}
   140 
   141 		T * operator->()
   142 		{
   143 			return m_Ptr;
   144 		}
   145 
   146 		iterator & operator++()		// preincrement
   147 		{
   148 			++m_Ptr;
   149 			return (*this);
   150 		}
   151 
   152 		iterator operator++(int)	// postincrement
   153 		{
   154 			iterator tmp = *this;
   155 			++m_Ptr;
   156 			return tmp;
   157 		}
   158 
   159 		iterator & operator--()		// predecrement
   160 		{
   161 			--m_Ptr;
   162 			return (*this);
   163 		}
   164 
   165 		iterator operator--(int)	// postdecrememnt
   166 		{
   167 			iterator tmp = *this;
   168 			--m_Ptr;
   169 			return tmp;
   170 		}
   171 
   172 		bool operator==(T * right) const
   173 		{
   174 			return (m_Ptr == right);
   175 		}
   176 
   177 		bool operator==(const iterator & right) const
   178 		{
   179 			return (m_Ptr == right.m_Ptr);
   180 		}
   181 
   182 		bool operator!=(T * right) const
   183 		{
   184 			return (m_Ptr != right);
   185 		}
   186 
   187 		bool operator!=(const iterator & right) const
   188 		{
   189 			return (m_Ptr != right.m_Ptr);
   190 		}
   191 
   192 		iterator & operator+=(size_t offset)
   193 		{
   194 			m_Ptr += offset;
   195 			return (*this);
   196 		}
   197 
   198 		iterator & operator-=(size_t offset)
   199 		{
   200 			m_Ptr -= offset;
   201 			return (*this);
   202 		}
   203 
   204 		iterator operator+(size_t offset) const
   205 		{
   206 			iterator tmp(*this);
   207 			tmp.m_Ptr += offset;
   208 			return tmp;
   209 		}
   210 
   211 		iterator operator-(size_t offset) const
   212 		{
   213 			iterator tmp(*this);
   214 			tmp.m_Ptr -= offset;
   215 			return tmp;
   216 		}
   217 
   218 		T & operator[](size_t offset)
   219 		{
   220 			return (*(*this + offset));
   221 		}
   222 
   223 		const T & operator[](size_t offset) const
   224 		{
   225 			return (*(*this + offset));
   226 		}
   227 
   228 		bool operator<(const iterator & right) const
   229 		{
   230 			return m_Ptr < right.m_Ptr;
   231 		}
   232 
   233 		bool operator>(const iterator & right) const
   234 		{
   235 			return m_Ptr > right.m_Ptr;
   236 		}
   237 
   238 		bool operator<=(const iterator & right) const
   239 		{
   240 			return m_Ptr <= right.m_Ptr;
   241 		}
   242 
   243 		bool operator>=(const iterator & right) const
   244 		{
   245 			return m_Ptr >= right.m_Ptr;
   246 		}
   247 
   248 		size_t operator-(const iterator & right) const
   249 		{
   250 			return m_Ptr - right.m_Ptr;
   251 		}
   252 	};
   253 
   254 	// constructors / destructors
   255 	CVector<T>()
   256 	{
   257 		m_Size = 0;
   258 		m_CurrentUsedSize = 0;
   259 		m_Data = NULL;
   260 	}
   261 
   262 	CVector<T>(const CVector<T> & other)
   263 	{
   264 		// copy data
   265 		m_Data = new T [other.m_CurrentUsedSize];
   266 		m_Size = other.m_CurrentUsedSize;
   267 		m_CurrentUsedSize = other.m_CurrentUsedSize;
   268 		for (size_t i=0; i<other.m_CurrentUsedSize; i++)
   269 			m_Data[i] = other.m_Data[i];
   270 	}
   271 
   272 	~CVector<T>()
   273 	{
   274 		clear();
   275 	}
   276 
   277 	CVector & operator =(const CVector<T> & other)
   278 	{
   279 		clear();
   280 		resize(other.size());
   281 		for (size_t i=0; i<other.size(); i++)
   282 			m_Data[i] = other.at(i);
   283 		return *this;
   284 	}
   285 
   286 	// interface
   287 	size_t size() const
   288 	{
   289 		return m_CurrentUsedSize;
   290 	}
   291 
   292 	size_t capacity() const
   293 	{
   294 		return m_Size;
   295 	}
   296 
   297 	iterator begin() const
   298 	{
   299 		return iterator(m_Data);
   300 	}
   301 
   302 	iterator end() const
   303 	{
   304 		return iterator(m_Data + m_CurrentUsedSize);
   305 	}
   306 
   307 	iterator iterAt(size_t pos)
   308 	{
   309 		if (pos > m_CurrentUsedSize)
   310 			assert(0);
   311 		return iterator(m_Data + pos);
   312 	}
   313 
   314 	bool reserve(size_t newSize)
   315 	{
   316 		if (newSize > m_Size)
   317 			return ChangeSize(newSize);
   318 		return true;
   319 	}
   320 
   321 	bool push_back(const T & elem)
   322 	{
   323 		++m_CurrentUsedSize;
   324 		if (!GrowIfNeeded())
   325 		{
   326 			--m_CurrentUsedSize;
   327 			return false;
   328 		}
   329 
   330 		m_Data[m_CurrentUsedSize - 1] = elem;
   331 		return true;
   332 	}
   333 
   334 	void pop_back()
   335 	{
   336 		--m_CurrentUsedSize;
   337 		if (m_CurrentUsedSize < 0)
   338 			m_CurrentUsedSize = 0;
   339 
   340 		FreeMemIfPossible();
   341 	}
   342 
   343 	bool resize(size_t newSize)
   344 	{
   345 		if (!ChangeSize(newSize))
   346 			return false;
   347 		m_CurrentUsedSize = newSize;
   348 		return true;
   349 	}
   350 
   351 	bool empty() const
   352 	{
   353 		return (m_CurrentUsedSize == 0);
   354 	}
   355 
   356 	T & at(size_t pos)
   357 	{
   358 		if (pos > m_CurrentUsedSize)
   359 		{
   360 			assert(0);
   361 		}
   362 		return m_Data[pos];
   363 	}
   364 
   365 	const  T & at(size_t pos) const
   366 	{
   367 		if (pos > m_CurrentUsedSize)
   368 		{
   369 			assert(0);
   370 		}
   371 		return m_Data[pos];
   372 	}
   373 
   374 	T & operator[](size_t pos)
   375 	{
   376 		return at(pos);
   377 	}
   378 
   379 	const T & operator[](size_t pos) const
   380 	{
   381 		return at(pos);
   382 	}
   383 
   384 	T & front()
   385 	{
   386 		if (m_CurrentUsedSize < 1)
   387 		{
   388 			assert(0);
   389 		}
   390 		return m_Data[0];
   391 	}
   392 
   393 	const T & front() const
   394 	{
   395 		if (m_CurrentUsedSize < 1)
   396 		{
   397 			assert(0);
   398 		}
   399 		return m_Data[0];
   400 	}
   401 
   402 	T & back()
   403 	{
   404 		if (m_CurrentUsedSize < 1)
   405 		{
   406 			assert(0);
   407 		}
   408 		return m_Data[m_CurrentUsedSize - 1];
   409 	}
   410 
   411 	const T & back() const
   412 	{
   413 		if (m_CurrentUsedSize < 1)
   414 		{
   415 			assert(0);
   416 		}
   417 		return m_Data[m_CurrentUsedSize - 1];
   418 	}
   419 
   420 	iterator insert(iterator where, const T & value)
   421 	{
   422 		// validate iter
   423 		if (where < m_Data || where > (m_Data + m_CurrentUsedSize))
   424 			return iterator(0);
   425 
   426 		size_t ofs = where - begin();
   427 
   428 		++m_CurrentUsedSize;
   429 		if (!GrowIfNeeded())
   430 		{
   431 			--m_CurrentUsedSize;
   432 			return false;
   433 		}
   434 
   435 		where = begin() + ofs;
   436 
   437 		// Move subsequent entries
   438 		for (T *ptr = m_Data + m_CurrentUsedSize - 2; ptr >= where.base(); --ptr)
   439 			*(ptr + 1) = *ptr;
   440 
   441 		*where.base() = value;
   442 
   443 		return where;
   444 	}
   445 
   446 	iterator erase(iterator where)
   447 	{
   448 		// validate iter
   449 		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
   450 			return iterator(0);
   451 
   452 		size_t ofs = where - begin();
   453 
   454 		if (m_CurrentUsedSize > 1)
   455 		{
   456 			// move
   457 			T *theend = m_Data + m_CurrentUsedSize;
   458 			for (T *ptr = where.base() + 1; ptr < theend; ++ptr)
   459 				*(ptr - 1) = *ptr;
   460 		}
   461 
   462 		--m_CurrentUsedSize;
   463 
   464 		FreeMemIfPossible();
   465 
   466 		return begin() + ofs;
   467 	}
   468 
   469 	void clear()
   470 	{
   471 		m_Size = 0;
   472 		m_CurrentUsedSize = 0;
   473 		if (m_Data)
   474 		{
   475 			delete [] m_Data;
   476 			m_Data = NULL;
   477 		}
   478 	}
   479 };
   480 };	//namespace SourceHook
   481 
   482 #endif // __CVECTOR_H__
   483