sourcehook/sh_stack.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 380 f9e21a2ac558
permissions -rw-r--r--
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 __SH_STACK_H__
    12 #define __SH_STACK_H__
    13 
    14 #include <stddef.h>
    15 
    16 #define SH_STACK_DEFAULT_SIZE 4
    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 		}
   105 		CStack(size_t size) : m_Elements(new T[size]),
   106 			m_AllocatedSize(size),
   107 			m_UsedSize(0)
   108 		{
   109 		}
   110 
   111 		CStack(const CStack &other) : m_Elements(NULL),
   112 			m_AllocatedSize(0),
   113 			m_UsedSize(0)
   114 		{
   115 			reserve(other.m_AllocatedSize);
   116 			m_UsedSize = other.m_UsedSize;
   117 			for (size_t i = 0; i < m_UsedSize; ++i)
   118 				m_Elements[i] = other.m_Elements[i];
   119 		}
   120 
   121 		~CStack()
   122 		{
   123 			if (m_Elements)
   124 				delete [] m_Elements;
   125 		}
   126 		
   127 		void operator=(const CStack &other)
   128 		{
   129 			if (m_AllocatedSize < other.m_AllocatedSize)
   130 			{
   131 				if (m_Elements)
   132 					delete [] m_Elements;
   133 				m_Elements = new T[other.m_AllocatedSize];
   134 				m_AllocatedSize = other.m_AllocatedSize;
   135 			}
   136 			m_UsedSize = other.m_UsedSize;
   137 			for (size_t i = 0; i < m_UsedSize; ++i)
   138 				m_Elements[i] = other.m_Elements[i];
   139 		}
   140 
   141 		bool push(const T &val)
   142 		{
   143 			if (m_UsedSize + 1 == m_AllocatedSize)
   144 			{
   145 				// zOHNOES! REALLOCATE!
   146 				m_AllocatedSize *= 2;
   147 				T *newElements = new T[m_AllocatedSize];
   148 				if (!newElements)
   149 				{
   150 					m_AllocatedSize /= 2;
   151 					return false;
   152 				}
   153 				if (m_Elements)
   154 				{
   155 					for (size_t i = 0; i < m_UsedSize; ++i)
   156 						newElements[i] = m_Elements[i];
   157 					delete [] m_Elements;
   158 				}
   159 				m_Elements = newElements;
   160 			}
   161 			m_Elements[m_UsedSize++] = val;
   162 			return true;
   163 		}
   164 
   165 		void pop()
   166 		{
   167 			--m_UsedSize;
   168 		}
   169 
   170 		void popall()
   171 		{
   172 			m_UsedSize = 0;
   173 		}
   174 
   175 		T &front()
   176 		{
   177 			return m_Elements[m_UsedSize - 1];
   178 		}
   179 
   180 		const T &front() const
   181 		{
   182 			return m_Elements[m_UsedSize - 1];
   183 		}
   184 
   185 		T &second()
   186 		{
   187 			return m_Elements[m_UsedSize - 2];
   188 		}
   189 
   190 		const T &second() const
   191 		{
   192 			return m_Elements[m_UsedSize - 2];
   193 		}
   194 
   195 		iterator begin()
   196 		{
   197 			return iterator(this, 0);
   198 		}
   199 		iterator end()
   200 		{
   201 			return iterator(this, m_UsedSize);
   202 		}
   203 
   204 		size_t size()
   205 		{
   206 			return m_UsedSize;
   207 		}
   208 		size_t capacity()
   209 		{
   210 			return m_AllocatedSize;
   211 		}
   212 		bool empty()
   213 		{
   214 			return m_UsedSize == 0 ? true : false;
   215 		}
   216 		bool reserve(size_t size)
   217 		{
   218 			if (size > m_AllocatedSize)
   219 			{
   220 				T *newElements = new T[size];
   221 				if (!newElements)
   222 					return false;
   223 				if (m_Elements)
   224 				{
   225 					for (size_t i = 0; i < m_UsedSize; ++i)
   226 						newElements[i] = m_Elements[i];
   227 					delete [] m_Elements;
   228 				}
   229 				m_Elements = newElements;
   230 				m_AllocatedSize = size;
   231 			}
   232 			return true;
   233 		}
   234 	};
   235 };	//namespace SourceHook
   236 
   237 #endif