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