Subversion Repositories spk

Rev

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

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