Subversion Repositories spk

#ifndef __LIST_H__
#define __LIST_H__

#include "../spkdll.h"
#include <vector>

//namespace SPK {
namespace Utils {


        template <class T>
        class CList
        {
        public:
                typedef typename std::vector<T *>::iterator iterator ;

        private:
                std::vector<T *> *_lItems;
                bool                     _bDontClear;
                typename std::vector<T *>::iterator _pItr;

        public:
                CList(bool bDontClear = false);
                ~CList();

                void clear();
                T *push_back(T *pItem);
                T *push_front(T *pItem);

                iterator begin();
                iterator end();
                T *first();
                T *next();

                bool empty() const;
                size_t size() const;

                T *get(int i) const;

                iterator remove(iterator itr);
                iterator removeAt(int idx);
        };


        ///////////////////////////////////////////////////////////////////////////

        template<class T>
        CList<T>::CList(bool bDontClear) : _bDontClear(bDontClear)
        {
                _lItems = new std::vector<T *>();
                _pItr = _lItems->end();
        }

        template <class T>
        CList<T>::~CList()
        {
                clear();
                delete _lItems;
        }

        template <class T>
        void CList<T>::clear()
        {
                if ( !_bDontClear ) {
                        for(std::vector<T *>::iterator itr = _lItems->begin(); itr != _lItems->end(); itr++) {
                                T *data = (*itr);
                                delete (*itr);
                        }
                }

                _lItems->clear();
        }

        template <class T>
        T *CList<T>::push_back(T *pItem)
        {
                _lItems->push_back(pItem);
                return pItem;
        }

        template <class T>
        T *CList<T>::push_front(T *pItem)
        {
                _lItems->insert(_lItems->begin(), pItem);
                return pItem;
        }

        template <class T>
        typename CList<T>::iterator CList<T>::begin()
        {
                return _lItems->begin();
        }

        template <class T>
        typename CList<T>::iterator CList<T>::end()
        {
                return _lItems->end();
        }

        template <class T>
        T *CList<T>::first()
        {
                if ( _lItems->empty() ) return NULL;
                _pItr = _lItems->begin();
                return *_pItr;
        }

        template <class T>
        T *CList<T>::next()
        {
                if ( _lItems->empty() ) return NULL;
                if ( _pItr == _lItems->end() ) return NULL;
                ++_pItr;
                if ( _pItr == _lItems->end() ) return NULL;
                return *_pItr;
        }

        template <class T>
        bool CList<T>::empty() const
        {
                return _lItems->empty();
        }

        template <class T>
        size_t CList<T>::size() const
        {
                return _lItems->size();
        }

        template <class T>
        T *CList<T>::get(int i) const
        {
                return (*_lItems)[i];
        }

        template <class T>
        typename CList<T>::iterator CList<T>::remove(CList<T>::iterator itr)
        {
                return _lItems->erase(itr);
        }

        template <class T>
        typename CList<T>::iterator CList<T>::removeAt(int idx)
        {
                return _lItems->erase(_lItems->begin() + idx);
        }
}
//}

#endif //__LIST_H__