Subversion Repositories spk

Rev

Rev 170 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
111 cycrow 1 
#ifndef __LIST_H__
2 
#define __LIST_H__
3 
 
4 
#include "../spkdll.h"
5 
#include <vector>
6 
 
7 
//namespace SPK {
8 
namespace Utils {
9 
 
112 cycrow 10 
 
111 cycrow 11 
	template <class T>
112 cycrow 12 
	class CList
111 cycrow 13 
	{
112 cycrow 14 
	public:
15 
		typedef typename std::vector<T *>::iterator iterator ;
16 
 
111 cycrow 17 
	private:
18 
		std::vector<T *> *_lItems;
19 
		bool			 _bDontClear;
20 
		typename std::vector<T *>::iterator _pItr;
21 
 
22 
	public:
23 
		CList(bool bDontClear = false);
24 
		~CList();
25 
 
26 
		void clear();
170 cycrow 27 
		void deleteItems();
28 
 
111 cycrow 29 
		T *push_back(T *pItem);
121 cycrow 30 
		T *push_front(T *pItem);
160 cycrow 31 
		void pop_back();
111 cycrow 32 
 
160 cycrow 33 
		iterator insert(iterator itr, T *pItem);
273 cycrow 34 
		iterator insertAt(size_t idx, T* pItem);
160 cycrow 35 
 
170 cycrow 36 
		iterator begin() const;
37 
		iterator end() const;
111 cycrow 38 
		T *first();
39 
		T *next();
40 
 
160 cycrow 41 
		T* front() const;
42 
		T* back() const;
43 
 
111 cycrow 44 
		bool empty() const;
112 cycrow 45 
		size_t size() const;
116 cycrow 46 
 
273 cycrow 47 
		T *get(size_t i) const;
121 cycrow 48 
 
49 
		iterator remove(iterator itr);
273 cycrow 50 
		iterator removeAt(size_t idx);
170 cycrow 51 
 
52 
		T* operator[](size_t idx);
111 cycrow 53 
	};
54 
 
55 
 
56 
	///////////////////////////////////////////////////////////////////////////
57 
 
58 
	template<class T>
59 
	CList<T>::CList(bool bDontClear) : _bDontClear(bDontClear)
60 
	{
61 
		_lItems = new std::vector<T *>();
62 
		_pItr = _lItems->end();
63 
	}
64 
 
65 
	template <class T>
66 
	CList<T>::~CList()
67 
	{
68 
		clear();
69 
		delete _lItems;
70 
	}
71 
 
72 
	template <class T>
73 
	void CList<T>::clear()
74 
	{
75 
		if ( !_bDontClear ) {
76 
			for(std::vector<T *>::iterator itr = _lItems->begin(); itr != _lItems->end(); itr++) {
113 cycrow 77 
				T *data = (*itr);
78 
				delete (*itr);
111 cycrow 79 
			}
80 
		}
81 
 
82 
		_lItems->clear();
83 
	}
84 
 
85 
	template <class T>
170 cycrow 86 
	void CList<T>::deleteItems()
87 
	{
88 
		for (std::vector<T*>::iterator itr = _lItems->begin(); itr != _lItems->end(); itr++) {
89 
			T* data = (*itr);
90 
			delete (*itr);
91 
		}
92 
		_lItems->clear();
93 
	}
94 
 
95 
	template <class T>
160 cycrow 96 
	T* CList<T>::push_back(T* pItem)
111 cycrow 97 
	{
98 
		_lItems->push_back(pItem);
99 
		return pItem;
100 
	}
101 
 
121 cycrow 102 
	template <class T>
160 cycrow 103 
	void CList<T>::pop_back()
104 
	{
105 
		_lItems->pop_back();
106 
	}
107 
 
108 
	template <class T>
109 
	typename CList<T>::iterator CList<T>::insert(CList<T>::iterator itr, T *pItem)
110 
	{
111 
		return _lItems->insert(itr, pItem);
112 
	}
113 
 
114 
	template <class T>
273 cycrow 115 
	typename CList<T>::iterator CList<T>::insertAt(size_t idx, T *pItem)
160 cycrow 116 
	{
117 
		return _lItems->insert(_lItems->begin() + idx, pItem);
118 
	}
119 
 
120 
	template <class T>
121 cycrow 121 
	T *CList<T>::push_front(T *pItem)
122 
	{
123 
		_lItems->insert(_lItems->begin(), pItem);
124 
		return pItem;
125 
	}
111 cycrow 126 
 
127 
	template <class T>
170 cycrow 128 
	typename CList<T>::iterator CList<T>::begin() const
111 cycrow 129 
	{
130 
		return _lItems->begin();
131 
	}
132 
 
133 
	template <class T>
170 cycrow 134 
	typename CList<T>::iterator CList<T>::end() const
111 cycrow 135 
	{
136 
		return _lItems->end();
137 
	}
138 
 
139 
	template <class T>
160 cycrow 140 
	T* CList<T>::front() const
111 cycrow 141 
	{
160 cycrow 142 
		if (_lItems->empty()) return NULL;
143 
		return _lItems->front();
144 
	}
145 
 
146 
	template <class T>
147 
	T* CList<T>::back() const
148 
	{
149 
		if (_lItems->empty()) return NULL;
150 
		return _lItems->back();
151 
	}
152 
 
153 
	template <class T>
154 
	T* CList<T>::first()
155 
	{
156 
		if (_lItems->empty()) return NULL;
111 cycrow 157 
		_pItr = _lItems->begin();
158 
		return *_pItr;
159 
	}
160 
 
161 
	template <class T>
162 
	T *CList<T>::next()
163 
	{
164 
		if ( _lItems->empty() ) return NULL;
165 
		if ( _pItr == _lItems->end() ) return NULL;
166 
		++_pItr;
167 
		if ( _pItr == _lItems->end() ) return NULL;
168 
		return *_pItr;
169 
	}
170 
 
171 
	template <class T>
172 
	bool CList<T>::empty() const
173 
	{
174 
		return _lItems->empty();
175 
	}
112 cycrow 176 
 
177 
	template <class T>
178 
	size_t CList<T>::size() const
179 
	{
180 
		return _lItems->size();
181 
	}
116 cycrow 182 
 
183 
	template <class T>
273 cycrow 184 
	T *CList<T>::get(size_t i) const
116 cycrow 185 
	{
186 
		return (*_lItems)[i];
187 
	}
121 cycrow 188 
 
189 
	template <class T>
190 
	typename CList<T>::iterator CList<T>::remove(CList<T>::iterator itr)
191 
	{
192 
		return _lItems->erase(itr);
193 
	}
194 
 
195 
	template <class T>
273 cycrow 196 
	typename CList<T>::iterator CList<T>::removeAt(size_t idx)
121 cycrow 197 
	{
198 
		return _lItems->erase(_lItems->begin() + idx);
199 
	}
170 cycrow 200 
 
201 
	template <class T>
202 
	T* CList<T>::operator[](size_t idx)
203 
	{
204 
		if(idx < _lItems->size())
205 
			return _lItems[idx];
206 
		return nullptr;
207 
	}
111 cycrow 208 
}
209 
//}
210 
 
211 
#endif //__LIST_H__