Subversion Repositories spk

Rev

Rev 116 | Rev 160 | Go to most recent revision | 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();
27 
		T *push_back(T *pItem);
121 cycrow 28 
		T *push_front(T *pItem);
111 cycrow 29 
 
112 cycrow 30 
		iterator begin();
31 
		iterator end();
111 cycrow 32 
		T *first();
33 
		T *next();
34 
 
35 
		bool empty() const;
112 cycrow 36 
		size_t size() const;
116 cycrow 37 
 
38 
		T *get(int i) const;
121 cycrow 39 
 
40 
		iterator remove(iterator itr);
41 
		iterator removeAt(int idx);
111 cycrow 42 
	};
43 
 
44 
 
45 
	///////////////////////////////////////////////////////////////////////////
46 
 
47 
	template<class T>
48 
	CList<T>::CList(bool bDontClear) : _bDontClear(bDontClear)
49 
	{
50 
		_lItems = new std::vector<T *>();
51 
		_pItr = _lItems->end();
52 
	}
53 
 
54 
	template <class T>
55 
	CList<T>::~CList()
56 
	{
57 
		clear();
58 
		delete _lItems;
59 
	}
60 
 
61 
	template <class T>
62 
	void CList<T>::clear()
63 
	{
64 
		if ( !_bDontClear ) {
65 
			for(std::vector<T *>::iterator itr = _lItems->begin(); itr != _lItems->end(); itr++) {
113 cycrow 66 
				T *data = (*itr);
67 
				delete (*itr);
111 cycrow 68 
			}
69 
		}
70 
 
71 
		_lItems->clear();
72 
	}
73 
 
74 
	template <class T>
75 
	T *CList<T>::push_back(T *pItem)
76 
	{
77 
		_lItems->push_back(pItem);
78 
		return pItem;
79 
	}
80 
 
121 cycrow 81 
	template <class T>
82 
	T *CList<T>::push_front(T *pItem)
83 
	{
84 
		_lItems->insert(_lItems->begin(), pItem);
85 
		return pItem;
86 
	}
111 cycrow 87 
 
88 
	template <class T>
112 cycrow 89 
	typename CList<T>::iterator CList<T>::begin()
111 cycrow 90 
	{
91 
		return _lItems->begin();
92 
	}
93 
 
94 
	template <class T>
112 cycrow 95 
	typename CList<T>::iterator CList<T>::end()
111 cycrow 96 
	{
97 
		return _lItems->end();
98 
	}
99 
 
100 
	template <class T>
101 
	T *CList<T>::first()
102 
	{
103 
		if ( _lItems->empty() ) return NULL;
104 
		_pItr = _lItems->begin();
105 
		return *_pItr;
106 
	}
107 
 
108 
	template <class T>
109 
	T *CList<T>::next()
110 
	{
111 
		if ( _lItems->empty() ) return NULL;
112 
		if ( _pItr == _lItems->end() ) return NULL;
113 
		++_pItr;
114 
		if ( _pItr == _lItems->end() ) return NULL;
115 
		return *_pItr;
116 
	}
117 
 
118 
	template <class T>
119 
	bool CList<T>::empty() const
120 
	{
121 
		return _lItems->empty();
122 
	}
112 cycrow 123 
 
124 
	template <class T>
125 
	size_t CList<T>::size() const
126 
	{
127 
		return _lItems->size();
128 
	}
116 cycrow 129 
 
130 
	template <class T>
131 
	T *CList<T>::get(int i) const
132 
	{
133 
		return (*_lItems)[i];
134 
	}
121 cycrow 135 
 
136 
	template <class T>
137 
	typename CList<T>::iterator CList<T>::remove(CList<T>::iterator itr)
138 
	{
139 
		return _lItems->erase(itr);
140 
	}
141 
 
142 
	template <class T>
143 
	typename CList<T>::iterator CList<T>::removeAt(int idx)
144 
	{
145 
		return _lItems->erase(_lItems->begin() + idx);
146 
	}
111 cycrow 147 
}
148 
//}
149 
 
150 
#endif //__LIST_H__