sourcehook/sh_stack.h
author Christian Hammacher <bmasterc@gmail.com>
Thu Oct 13 23:42:51 2005 +0000 (2005-10-13)
changeset 130 ba6b4cb2505a
parent 129 1e021006dae7
child 133 ffe46578a1ae
permissions -rw-r--r--
I can't spell "LATEST"
     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 __SH_STACK_H__
    12 #define __SH_STACK_H__
    13 
    14 #define SH_STACK_DEFAULT_SIZE 4
    15 
    16 #include <assert.h>
    17 
    18 namespace SourceHook
    19 {
    20 	// Vector
    21 	template <class T> class CStack
    22 	{
    23 		T *m_Elements;
    24 		size_t m_AllocatedSize;
    25 		size_t m_UsedSize;
    26 	public:
    27 		friend class iterator;
    28 		class iterator
    29 		{
    30 			CStack<T> *m_pParent;
    31 			size_t m_Index;
    32 		public:
    33 			iterator(CStack<T> *pParent, size_t id) : m_pParent(pParent), m_Index(id)
    34 			{
    35 			}
    36 
    37 			iterator(CStack<T> *pParent) : m_pParent(pParent), m_Index(0)
    38 			{
    39 			}
    40 			
    41 			iterator() : m_pParent(NULL), m_Index(0)
    42 			{
    43 			}
    44 
    45 			T &operator *()
    46 			{
    47 				return m_pParent->m_Elements[m_Index];
    48 			}
    49 			const T &operator *() const
    50 			{
    51 				return m_pParent->m_Elements[m_Index];
    52 			}
    53 			
    54 			T * operator->()
    55 			{
    56 				return m_pParent->m_Elements + m_Index;
    57 			}
    58 
    59 			const T * operator->() const
    60 			{
    61 				return m_pParent->m_Elements + m_Index;
    62 			}
    63 
    64 			iterator & operator++()		// preincrement
    65 			{
    66 				++m_Index;
    67 				return (*this);
    68 			}
    69 
    70 			iterator operator++(int)	// postincrement
    71 			{
    72 				iterator tmp = *this;
    73 				++m_Index;
    74 				return tmp;
    75 			}
    76 
    77 			iterator & operator--()		// predecrement
    78 			{
    79 				--m_Index;
    80 				return (*this);
    81 			}
    82 
    83 			iterator operator--(int)	// postdecrememnt
    84 			{
    85 				iterator tmp = *this;
    86 				--m_Index;
    87 				return tmp;
    88 			}
    89 
    90 			bool operator==(const iterator & right) const
    91 			{
    92 				return (m_pParent == right.m_pParent && m_Index == right.m_Index);
    93 			}
    94 
    95 			bool operator!=(const iterator & right) const
    96 			{
    97 				return !(*this == right);
    98 			}
    99 		};
   100 		CStack() : m_Elements(new T[SH_STACK_DEFAULT_SIZE]),
   101 			m_AllocatedSize(SH_STACK_DEFAULT_SIZE),
   102 			m_UsedSize(0)
   103 		{
   104 			assert(m_Elements);
   105 		}
   106 		CStack(size_t size) : m_Elements(new T[size]),
   107 			m_AllocatedSize(size),
   108 			m_UsedSize(0)
   109 		{
   110 			assert(m_Elements);
   111 		}
   112 
   113 		CStack(const CStack &other) : m_Elements(NULL),
   114 			m_AllocatedSize(0),
   115 			m_UsedSize(0)
   116 		{
   117 			assert(reserve(other.m_AllocatedSize) && m_Elements);
   118 			m_UsedSize = other.m_UsedSize;
   119 			for (size_t i = 0; i < m_UsedSize; ++i)
   120 				m_Elements[i] = other.m_Elements[i];
   121 		}
   122 
   123 		~CStack()
   124 		{
   125 			if (m_Elements)
   126 				delete [] m_Elements;
   127 		}
   128 		
   129 		void operator=(const CStack &other)
   130 		{
   131 			if (m_AllocatedSize < other.m_AllocatedSize)
   132 			{
   133 				if (m_Elements)
   134 					delete [] m_Elements;
   135 				m_Elements = new T[other.m_AllocatedSize];
   136 				assert(m_Elements);
   137 				m_AllocatedSize = other.m_AllocatedSize;
   138 			}
   139 			m_UsedSize = other.m_UsedSize;
   140 			for (size_t i = 0; i < m_UsedSize; ++i)
   141 				m_Elements[i] = other.m_Elements[i];
   142 		}
   143 
   144 		bool push(const T &val)
   145 		{
   146 			if (m_UsedSize + 1 == m_AllocatedSize)
   147 			{
   148 				// zOHNOES! REALLOCATE!
   149 				m_AllocatedSize *= 2;
   150 				T *newElements = new T[m_AllocatedSize];
   151 				if (!newElements)
   152 				{
   153 					m_AllocatedSize /= 2;
   154 					return false;
   155 				}
   156 				if (m_Elements)
   157 				{
   158 					for (size_t i = 0; i < m_UsedSize; ++i)
   159 						newElements[i] = m_Elements[i];
   160 					delete [] m_Elements;
   161 				}
   162 				m_Elements = newElements;
   163 			}
   164 			m_Elements[m_UsedSize++] = val;
   165 			return true;
   166 		}
   167 		void pop()
   168 		{
   169 			--m_UsedSize;
   170 		}
   171 
   172 		T &front()
   173 		{
   174 			return m_Elements[m_UsedSize - 1];
   175 		}
   176 
   177 		const T &front() const
   178 		{
   179 			return m_Elements[m_UsedSize - 1];
   180 		}
   181 
   182 		iterator begin()
   183 		{
   184 			return iterator(this, 0);
   185 		}
   186 		iterator end()
   187 		{
   188 			return iterator(this, m_UsedSize);
   189 		}
   190 
   191 		size_t size()
   192 		{
   193 			return m_UsedSize;
   194 		}
   195 		size_t capacity()
   196 		{
   197 			return m_AllocatedSize;
   198 		}
   199 		bool empty()
   200 		{
   201 			return m_UsedSize == 0 ? true : false;
   202 		}
   203 		bool reserve(size_t size)
   204 		{
   205 			if (size > m_AllocatedSize)
   206 			{
   207 				T *newElements = new T[size];
   208 				if (!newElements)
   209 					return false;
   210 				if (m_Elements)
   211 				{
   212 					for (size_t i = 0; i < m_UsedSize; ++i)
   213 						newElements[i] = m_Elements[i];
   214 					delete [] m_Elements;
   215 				}
   216 				m_Elements = newElements;
   217 				m_AllocatedSize = size;
   218 			}
   219 			return true;
   220 		}
   221 	};
   222 };	//namespace SourceHook
   223 
   224 #endif