Subversion Repositories spk

#ifndef EXT_SIMPLE_LIST_INCLUDED

#define EXT_SIMPLE_LIST_INCLUDED

namespace ext

{

template <class Ty>

class simple_list

{

	public:

		typedef Ty value_type;

		typedef Ty& reference;

		typedef const Ty& const_reference;

		typedef size_t size_type;

	private:

		struct node

		{

			node *next;

			value_type val;

		};

		node *m_head;

		node *m_last;

		size_type m_size;

	public:

		class const_iterator

		{

			protected:

				node *m_node;

			public:

				const_iterator() { }

				const_iterator(node *n) { m_node=n; }

				const_iterator& operator ++() { m_node=m_node->next; return *this; }

				const_iterator operator ++(int) { node *old=m_node; m_node=m_node->next; return const_iterator(old); }

				const_reference operator *() const { return m_node->val; }

				const_reference operator ->() const { return m_node->val; }

				bool operator ==(const_iterator& right) const { return m_node==right.m_node; }

				bool operator !=(const_iterator& right) const { return m_node!=right.m_node; }

		};

		class iterator : public const_iterator

		{

			public:

				iterator() { }

				iterator(node *n) : const_iterator(n) { }

				iterator& operator ++() { m_node=m_node->next; return *this; }

				iterator operator ++(int) { node *old=m_node; m_node=m_node->next; return iterator(old); }

				reference operator *() { return m_node->val; }

				reference operator ->() { return m_node->val; }

		};

	public:

		simple_list() { m_head=new node(); m_head->next=m_head; clear(); }

		simple_list(const simple_list& other)

		{

			m_head=new node(); m_head->next=m_head; clear();

			for(const_iterator &it=other.begin(); it!=other.end(); ++it){

				push_back(*it);

			}

		}

		~simple_list() { clear(); delete m_head; }

		void clear()

		{

			node *n, *old;

			for(old=0, n=m_head->next; n!=m_head; old=n, n=n->next){

				delete old;

			}

			delete old;

			m_head->next=m_head;

			m_last=m_head;

			m_size=0;

		}

		iterator begin() { return iterator(m_head->next); }

		iterator end() { return iterator(m_head); }

		const_iterator begin() const { return const_iterator(m_head->next); }

		const_iterator end() const { return const_iterator(m_head); }

		size_type size() const { return m_size; }

		iterator push_back(const_reference val)

		{

			node *n=new node();

			n->val=val;

			m_last->next=n;

			n->next=m_head;

			m_last=n;

			m_size++;

			return iterator(n);

		}

		reference front() { return *begin(); }

		reference back() { return m_last->val; }

		const_reference front() const { return *begin(); }

		const_reference back() const { return m_last->val; }

};

};

#endif // !defined(EXT_SIMPLE_LIST_INCLUDED)