Class Hierarchy   Compound List   File List   Header Files   Compound Members   File Members  

---

common/suif_list.h

This is the verbatim text of the suif_list.h include file.

---

#ifndef _LIST_H_
#define _LIST_H_



#if defined(USE_STL) || defined(USE_STL_LIST)
#include <list>
#else


template <class T>
class list {
public:
	typedef T value_type;

        class Node {
            public:
               Node *pvPrev;
               T data;
               Node *pvNext;
               Node(const T& x) : pvPrev(0),data(x),pvNext(0) {}
	    private:
	       Node(const Node&) : pvPrev(0),data(0),pvNext(0) {}
	       Node &operator=(const Node &other) {
		 pvPrev = other.pvPrev; data= other.data;
		 pvNext = other.pvNext; return(*this);
	       }
               };

	class literator {
		friend class list<T>;
	protected:
		Node *node;
	public:
		literator& operator--() {
			node = node->pvPrev;
			return *this;
		}
		literator operator--(int dummy) {
			literator iter(*this);
			node = node->pvPrev;
			return iter;
		}
		literator operator++(int dummy) {
			literator iter(*this);
			node = node->pvNext;
			return iter;
		}
		literator& operator++() {
			node = node->pvNext;
			return *this;
		}
		T& operator*() const { return node->data; }	
		bool operator==(const literator& iter) const {
			return (node == iter.node);
		}
		bool operator!=(const literator& iter) const {
			return (node != iter.node);
		}
		literator &operator =(const literator &x) {node = x.node;return *this;}
		literator(const literator &x) : node(x.node) {}
		literator() : node(0) {}
	protected:
		literator &operator =(Node *x) {node = x;return *this;}
		literator(Node *x) : node(x) {}
	};
        typedef literator iterator;

protected:
        unsigned m_nLength;

	void clone_list(const list &x) {
	    for (iterator i=x.begin();i != x.end();i++)
		push_back(*i);
	    }
	
	void init_list() {
	    m_begin = (Node *)0;
	    m_end = (Node *)0;
            m_nLength=0;
	    }
	
protected:
	iterator m_begin;
	iterator m_end;

public:
	list() :
	  m_nLength(0), m_begin(), m_end()
                {
		init_list();
		}

	~list() {
		clear_list();
		}

	
        void clear_list() {
            while (m_nLength > 0)
                pop_front();
	    init_list();
            }

	
	bool empty() const { return m_nLength == 0; }

	
	unsigned length() const { return m_nLength; }

	
	unsigned size() const { return m_nLength; }

		
	iterator insert(const iterator& pos, const T& x) { // add x before pos
		Node *new_node = new Node(x);
		new_node->pvNext = pos.node;
		if (pos.node != 0)
		    {
		    new_node->pvPrev = pos.node->pvPrev;
		    pos.node->pvPrev = new_node;
		    }
		else
		    {
		    new_node->pvPrev = m_end.node;
		    m_end = new_node;
		    }
		if (new_node->pvPrev != 0)
		    new_node->pvPrev->pvNext = new_node;
		else
		    m_begin = new_node;

		m_nLength++;
		return iterator(new_node);
		}

	
	iterator get_nth(int pos) const {
	    iterator x = begin();
            while ((x != end()) && (pos > 0))
                {
                x++;
                pos--;
                }
	    return x;
	    }


	
        iterator insert(int pos,const T& y) {
            iterator x = get_nth(pos);
            return insert(x,y);
            }

	iterator begin() { return m_begin; }
	iterator begin() const { return m_begin; }
	iterator end() { return iterator(0);}
	iterator end() const { return iterator(0);}

	
	void push_front(const T& x) { insert(begin(), x); }

	
	void pop_front() {
		erase(begin());
		}

	
	void push_back(const T& x) { insert(end(), x); }

	
	void pop_back() {
		erase(m_end);
		}

		
	T & front() { return m_begin.node->data; }

	
	T & back() { return m_end.node->data; }

	
	T & operator [](int i) const {
	    iterator x = get_nth(i);
	    return x.node->data;
	    }

	
	iterator erase(const iterator& pos) {
	        iterator ret_iter = pos;
	        Node *the_node = pos.node;
		// shouldn't this be an assertion???
		if (!the_node) {
		    return(ret_iter);
		    }
		ret_iter++;
		if (the_node->pvPrev)
		    (the_node->pvPrev->pvNext) = (the_node->pvNext);
		else
		    m_begin = (the_node->pvNext);
		if (the_node->pvNext)
		    (the_node->pvNext->pvPrev) = (the_node->pvPrev);
		else
		  m_end = (the_node->pvPrev);
		delete (the_node);
		m_nLength--;
		return(ret_iter);
		}

        
        iterator erase(int pos) {
            iterator x = get_nth(pos);
            return(erase(x));
            }

	list & operator =(const list &x) {
	    clear_list();
	    clone_list(x);
	    return *this;
	    }

	list(const list &x) {
	    init_list();
	    clone_list(x);
	    }
		
private:


}; // class list


#endif
#endif

---