sourcehook/sh_list.h
author David Anderson <dvander@alliedmods.net>
Mon Oct 03 18:37:35 2005 +0000 (2005-10-03)
changeset 120 ea2afceb651e
parent 119 8b8ccac34850
child 150 22fbddfa0209
permissions -rw-r--r--
Should work on both now!1111gaben
     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): David "BAILOPAN" Anderson
     8 * ============================
     9 */
    10 
    11 #ifndef _INCLUDE_SMM_LIST_H
    12 #define _INCLUDE_SMM_LIST_H
    13 
    14 #include <new>
    15 #include <malloc.h>
    16 
    17 namespace SourceHook
    18 {
    19 //This class is from CSDM for AMX Mod X
    20 template <class T>
    21 class List
    22 {
    23 public:
    24 	class iterator;
    25 	friend class iterator;
    26 	class ListNode
    27 	{
    28 	public:
    29 		ListNode(const T & o) : obj(o) { };
    30 		ListNode() { };
    31 		T obj;
    32 		ListNode *next;
    33 		ListNode *prev;
    34 	};
    35 private:
    36 	ListNode *_Initialize()
    37 	{
    38 		ListNode *n = (ListNode *)malloc(sizeof(ListNode));
    39 		n->next = NULL;
    40 		n->prev = NULL;
    41 		return n;
    42 	}
    43 public:
    44 	List() : m_Head(_Initialize()), m_Size(0)
    45 	{
    46 	}
    47 	List(const List &src) : m_Head(_Initialize()), m_Size(0)
    48 	{
    49 		iterator iter;
    50 		for (iter=src.begin(); iter!=src.end(); iter++)
    51 			push_back( (*iter) );
    52 	}
    53 	~List()
    54 	{
    55 		clear();
    56 		if (m_Head)
    57 		{
    58 			free(m_Head);
    59 			m_Head = NULL;
    60 		}
    61 	}
    62 	void push_back(const T &obj)
    63 	{
    64 		ListNode *node = new ListNode(obj);
    65 
    66 		if (!m_Head->prev)
    67 		{
    68 			//link in the node as the first item 
    69 			node->next = m_Head;
    70 			node->prev = m_Head;
    71 			m_Head->prev = node;
    72 			m_Head->next = node;
    73 		} else {
    74 			node->prev = m_Head->prev;
    75 			node->next = m_Head;
    76 			m_Head->prev->next = node;
    77 			m_Head->prev = node;
    78 		}
    79 		m_Size++;
    80 	}
    81 	size_t size()
    82 	{
    83 		return m_Size;
    84 	}
    85 	void clear()
    86 	{
    87 		ListNode *node = m_Head->next;
    88 		ListNode *temp;
    89 		m_Head->next = NULL;
    90 		m_Head->prev = NULL;
    91 		while (node && node != m_Head)
    92 		{
    93 			temp = node->next;
    94 			delete node;
    95 			node = temp;
    96 		}
    97 		m_Size = 0;
    98 	}
    99 	bool empty()
   100 	{
   101 		return (m_Head->next == NULL);
   102 	}
   103 	T & back()
   104 	{
   105 		return m_Head->prev->obj;
   106 	}
   107 private:
   108 	ListNode *m_Head;
   109 	size_t m_Size;
   110 public:
   111 	class iterator
   112 	{
   113 	friend class List;
   114 	public:
   115 		iterator()
   116 		{
   117 			m_This = NULL;
   118 		}
   119 		iterator(const List &src)
   120 		{
   121 			m_This = src.m_Head;
   122 		}
   123 		iterator(ListNode *n) : m_This(n)
   124 		{
   125 		}
   126 		iterator(const iterator &where)
   127 		{
   128 			m_This = where.m_This;
   129 		}
   130 		//pre decrement
   131 		iterator & operator--()
   132 		{
   133 			if (m_This)
   134 				m_This = m_This->prev;
   135 			return *this;
   136 		}
   137 		//post decrement
   138 		iterator operator--(int)
   139 		{
   140 			iterator old(*this);
   141 			if (m_This)
   142 				m_This = m_This->prev;
   143 			return old;
   144 		}	
   145 		
   146 		//pre increment
   147 		iterator & operator++()
   148 		{
   149 			if (m_This)
   150 				m_This = m_This->next;
   151 			return *this;
   152 		}
   153 		//post increment
   154 		iterator operator++(int)
   155 		{
   156 			iterator old(*this);
   157 			if (m_This)
   158 				m_This = m_This->next;
   159 			return old;
   160 		}
   161 		
   162 		const T & operator * () const
   163 		{
   164 			return m_This->obj;
   165 		}
   166 		T & operator * ()
   167 		{
   168 			return m_This->obj;
   169 		}
   170 		
   171 		T * operator -> ()
   172 		{
   173 			return &(m_This->obj);
   174 		}
   175 		const T * operator -> () const
   176 		{
   177 			return &(m_This->obj);
   178 		}
   179 		
   180 		bool operator != (const iterator &where) const
   181 		{
   182 			return (m_This != where.m_This);
   183 		}
   184 		bool operator ==(const iterator &where) const
   185 		{
   186 			return (m_This == where.m_This);
   187 		}
   188 	private:
   189 		ListNode *m_This;
   190 	};
   191 public:
   192 	iterator begin() const
   193 	{
   194 		if (m_Size)
   195 			return iterator(m_Head->next);
   196 		else
   197 			return iterator(m_Head);
   198 	}
   199 	iterator end() const
   200 	{
   201 		return iterator(m_Head);
   202 	}
   203 	iterator erase(iterator &where)
   204 	{
   205 		ListNode *pNode = where.m_This;
   206 		iterator iter(where);
   207 		iter++;
   208 
   209 		//If we are both the head and tail...
   210 		if (m_Head->next == pNode && m_Head->prev == pNode)
   211 		{
   212 			m_Head->next = NULL;
   213 			m_Head->prev = NULL;
   214 		} else if (m_Head->next == pNode) {
   215 			//we are only the first
   216 			pNode->next->prev = m_Head;
   217 			m_Head->next = pNode->next;
   218 		} else if (m_Head->prev == pNode) {
   219 			//we are the tail
   220 			pNode->prev->next = m_Head;
   221 			m_Head->prev = pNode->prev;
   222 		} else {
   223 			//middle unlink
   224 			pNode->prev->next = pNode->next;
   225 			pNode->next->prev = pNode->prev;
   226 		}
   227 
   228 		delete pNode;
   229 		m_Size--;
   230 
   231 		return iter;
   232 	}
   233 public:
   234 	void remove(const T & obj)
   235 	{
   236 		iterator b;
   237 		for (b=begin(); b!=end(); b++)
   238 		{
   239 			if ( (*b) == obj )
   240 			{
   241 				erase( b );
   242 				break;
   243 			}
   244 		}
   245 	}
   246 	template <typename U>
   247 	iterator find(const U & equ)
   248 	{
   249 		iterator iter;
   250 		for (iter=begin(); iter!=end(); iter++)
   251 		{
   252 			if ( (*iter) == equ )
   253 				return iter;
   254 		}
   255 		return end();
   256 	}
   257 	List & operator =(List &src)
   258 	{
   259 		clear();
   260 		iterator iter;
   261 		for (iter=src.begin(); iter!=src.end(); iter++)
   262 			push_back( (*iter) );
   263 		return *this;
   264 	}
   265 };
   266 };	//NAMESPACE
   267 
   268 #endif //_INCLUDE_CSDM_LIST_H