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