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