Subversion Repositories spk

Rev

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

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