sourcehook/sh_vector.h
author Scott Ehlert <ds@alliedmods.net>
Fri Aug 10 23:43:16 2007 +0000 (2007-08-10)
changeset 346 d0868271663a
parent 294 0d87bc8606f8
child 427 0ded1b59879c
permissions -rwxr-xr-x
Reformatted output of meta list command
     1 /* ======== SourceMM ========
     2 * Copyright (C) 2004-2007 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 		ChangeSize(other.size());
   281 		m_CurrentUsedSize = other.size();
   282 		for (size_t i=0; i<other.size(); i++)
   283 			m_Data[i] = other.at(i);
   284 		return *this;
   285 	}
   286 
   287 	// interface
   288 	size_t size() const
   289 	{
   290 		return m_CurrentUsedSize;
   291 	}
   292 
   293 	size_t capacity() const
   294 	{
   295 		return m_Size;
   296 	}
   297 
   298 	iterator begin() const
   299 	{
   300 		return iterator(m_Data);
   301 	}
   302 
   303 	iterator end() const
   304 	{
   305 		return iterator(m_Data + m_CurrentUsedSize);
   306 	}
   307 
   308 	iterator iterAt(size_t pos)
   309 	{
   310 		if (pos > m_CurrentUsedSize)
   311 			assert(0);
   312 		return iterator(m_Data + pos);
   313 	}
   314 
   315 	bool reserve(size_t newSize)
   316 	{
   317 		if (newSize > m_Size)
   318 			return ChangeSize(newSize);
   319 		return true;
   320 	}
   321 
   322 	bool push_back(const T & elem)
   323 	{
   324 		++m_CurrentUsedSize;
   325 		if (!GrowIfNeeded())
   326 		{
   327 			--m_CurrentUsedSize;
   328 			return false;
   329 		}
   330 
   331 		m_Data[m_CurrentUsedSize - 1] = elem;
   332 		return true;
   333 	}
   334 
   335 	void pop_back()
   336 	{
   337 		--m_CurrentUsedSize;
   338 		if (m_CurrentUsedSize < 0)
   339 			m_CurrentUsedSize = 0;
   340 
   341 		FreeMemIfPossible();
   342 	}
   343 
   344 	bool resize(size_t newSize)
   345 	{
   346 		return resize(newSize, T());
   347 	}
   348 
   349 	bool resize(size_t newSize, T defval)
   350 	{
   351 		if (!ChangeSize(newSize))
   352 			return false;
   353 		for (size_t i = m_CurrentUsedSize; i < newSize; ++i)
   354 			m_Data[i] = defval;
   355 		m_CurrentUsedSize = newSize;
   356 		return true;
   357 	}
   358 
   359 	bool empty() const
   360 	{
   361 		return (m_CurrentUsedSize == 0);
   362 	}
   363 
   364 	T & at(size_t pos)
   365 	{
   366 		if (pos > m_CurrentUsedSize)
   367 		{
   368 			assert(0);
   369 		}
   370 		return m_Data[pos];
   371 	}
   372 
   373 	const  T & at(size_t pos) const
   374 	{
   375 		if (pos > m_CurrentUsedSize)
   376 		{
   377 			assert(0);
   378 		}
   379 		return m_Data[pos];
   380 	}
   381 
   382 	T & operator[](size_t pos)
   383 	{
   384 		return at(pos);
   385 	}
   386 
   387 	const T & operator[](size_t pos) const
   388 	{
   389 		return at(pos);
   390 	}
   391 
   392 	T & front()
   393 	{
   394 		if (m_CurrentUsedSize < 1)
   395 		{
   396 			assert(0);
   397 		}
   398 		return m_Data[0];
   399 	}
   400 
   401 	const T & front() const
   402 	{
   403 		if (m_CurrentUsedSize < 1)
   404 		{
   405 			assert(0);
   406 		}
   407 		return m_Data[0];
   408 	}
   409 
   410 	T & back()
   411 	{
   412 		if (m_CurrentUsedSize < 1)
   413 		{
   414 			assert(0);
   415 		}
   416 		return m_Data[m_CurrentUsedSize - 1];
   417 	}
   418 
   419 	const T & back() const
   420 	{
   421 		if (m_CurrentUsedSize < 1)
   422 		{
   423 			assert(0);
   424 		}
   425 		return m_Data[m_CurrentUsedSize - 1];
   426 	}
   427 
   428 	iterator insert(iterator where, const T & value)
   429 	{
   430 		// validate iter
   431 		if (where < m_Data || where > (m_Data + m_CurrentUsedSize))
   432 			return iterator(0);
   433 
   434 		size_t ofs = where - begin();
   435 
   436 		++m_CurrentUsedSize;
   437 		if (!GrowIfNeeded())
   438 		{
   439 			--m_CurrentUsedSize;
   440 			return false;
   441 		}
   442 
   443 		where = begin() + ofs;
   444 
   445 		// Move subsequent entries
   446 		for (T *ptr = m_Data + m_CurrentUsedSize - 2; ptr >= where.base(); --ptr)
   447 			*(ptr + 1) = *ptr;
   448 
   449 		*where.base() = value;
   450 
   451 		return where;
   452 	}
   453 
   454 	iterator erase(iterator where)
   455 	{
   456 		// validate iter
   457 		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
   458 			return iterator(0);
   459 
   460 		size_t ofs = where - begin();
   461 
   462 		if (m_CurrentUsedSize > 1)
   463 		{
   464 			// move
   465 			T *theend = m_Data + m_CurrentUsedSize;
   466 			for (T *ptr = where.base() + 1; ptr < theend; ++ptr)
   467 				*(ptr - 1) = *ptr;
   468 		}
   469 
   470 		--m_CurrentUsedSize;
   471 
   472 		FreeMemIfPossible();
   473 
   474 		return begin() + ofs;
   475 	}
   476 
   477 	void clear()
   478 	{
   479 		m_Size = 0;
   480 		m_CurrentUsedSize = 0;
   481 		if (m_Data)
   482 		{
   483 			delete [] m_Data;
   484 			m_Data = NULL;
   485 		}
   486 	}
   487 };
   488 };	//namespace SourceHook
   489 
   490 #endif // __CVECTOR_H__