Subversion Repositories spk

Rev

Rev 160 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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